Old Southwest free art gallery stop today by the fountain, tentacle benches in stone. Warm air, sound of water carrying down a quiet street. Glass-front little library of tiny art. Left a space cat and spider-legged 3D printed bowl (looked like it might scuttle off if I turned away), took handmade paper with soft edges, flecks of color pressed in. Quiet art barter, no words. Visit it, and share your art, and take some!

Drove over to Nakhon Thai, the table outside under just enough shade to make the sun friendly. Cloverdale traffic hum, a light breeze threading between cars. Door opening now and then, letting out a gust of lemongrass and curry like someone cracked a window into summer. Spring rolls crisply hot and cool dips.  Fried tofu, gold shell over soft middle. Pad prik king,  beans still-crisp, slow red curry heat. Drunken noodles with basil bright, trace of wok char. Cold drinks sweating in time with me, so glad August was being gentle. Second visit, just as good as the first. Will return.

Bakery stop for a sweet before heading home. More on that later.

We started the evening at the free little art gallery in Old Southwest, the one by the fountain with the tentacle-wrapped benches carved from limestone and marble. Quiet street, water sound carrying in the warm air. The glass-fronted box was full of tiny works. We left a 3D printed bowl on spider legs and took a packet of homemade paper, soft-edged with flecks of color pressed in. A quiet trade between strangers.

From there we headed to Nakhon Thai Cuisine and sat at the little table out front, shaded just enough to keep the sun gentle. The steady hum of Cloverdale traffic, and now and then the door opening to let a wave of lemongrass and curry drift out. We started with spring rolls, crisp and fresh with a cool dipping sauce, and fried tofu with a soft middle and golden shell.

Pad prik king came out rich with red curry, green beans still crisp, the heat slow to build. Drunken noodles on the other plate, wide and tender with that hint of char from the wok, basil bright in the mix. Cold drinks kept pace with the spice. It was our second visit, and the food was equally excellent both times. The value was very good for both the quality and the quantity, the sort of meal that feels worth coming back for.

Afterward, we continued on to the bakery for a little sweet treat before heading home. There will be more on that later.

—

Edited revision

Here’s the updated Scottobear-style entry with your cooler August weather detail worked in so it feels natural to the scene.


—

2025-08-08 21:37
Mood: content, lightly sun-warmed
Weather: 77°F, comfortably cool for August, whisper of a breeze, fountain splash soundtrack

We drove to the Old Southwest free art gallery by the fountain, where stone tentacle benches curled in lazy spirals. The mild air carried the sound of water spilling into a basin, drifting down the quiet street. A glass-front little art library held shelves of tiny treasures. I left a spider-legged 3D printed bowl that looked like it might scuttle off if you blinked, and in return I took handmade paper with soft deckled edges, flecks of color suspended like tiny petals. It was a silent trade, understood without words.

From there we headed over to Nakhon Thai and found a small table out front, shaded just enough to make the sun feel friendly. The Cloverdale traffic hummed in the background while a light breeze moved between the parked cars. Each time the door opened, a rush of lemongrass and curry spilled into the street, like someone had briefly opened a window into summer.

The spring rolls were crisp and cool, the fried tofu wore a gold shell over a cloud-soft middle, and the pad prik king arrived with beans that still had a snap and a slow-building red curry heat. Drunken noodles came fragrant with bright basil and carried a trace of wok char. Cold drinks sweated on the table at the same pace I did. This was our second visit, and it was every bit as good as the first. We will be back.


Before heading home we stopped at the bakery for something sweet, but that is a story for later.

When the moon hits your knees
And you mispronounce trees
Sycamore

Sycamore Station on Dutch Oven Road — a place of gentle wonder, where a door opens into something more than retail. I wandered in one morning when the air still held dew, and found myself in a light-splashed space where food smells like home, curiosity lingers on every shelf, and time tilts just a fraction slower.

The blueberry grilled cheese was a whisper of pastel heaven: jam and goat cheese, basil’s quiet hum, jalapeño offering a gentle nudge. I sipped a cold brew, deep and rich, and let the warmth from the wood-floored room settle in my chest.

Around me—pottery that feels hand-warmed by the artist’s fingers, candles that glow like hidden geodes, bowls carved from wood that once lived in forest twilight. The air carried the memory of markets past, of vendors setting up under suns that only half-remembered themselves.

In the back, a community room awaited: its tables folding into stillness or gathering space for readers and painters and dreamers. Soon I discovered — it was all of us, drawn there to breathe.

This is more than a stop. It’s a threshold between trail and table, quiet and connection. I left with a sticker in my pocket, a card for a sign‑making class in my bag, and the feeling that someone had saved a corner of Roanoke for moments like this.

I’ll be back. Maybe next time I’ll bring a friend, or linger over books and floated root beer. Sycamore Station isn’t just a place to pause — it’s one to return to.

[Wednesday, August 6, 2025]

Doctor’s appointment first thing this morning — a quick check-in, mostly routine. A waiting room with daytime television turned down too low to make out the words, just enough to let the commercials feel like a soft menace. The nurse was kind, and the doctor efficient. Blood pressure fine, meds adjusted slightly.

Afterward, I swung past the CVS drive-through on Chestnut, where the speaker always feels like it’s underwater. Picked up my prescriptions — the usual refills. A little more traffic than expected, but the breeze today helped. Not quite fall yet, but the air is thinking about it. A hint of cool under the sun. Maybe just wishful thinking. It’s nice that the person at the window knows me enough to ask after family, and if the meds are for me or she.

Kroger pickup went smoothly. Ordered last night, a few substitutions — they were out of my usual crackers, but replaced them with the off-brand cousins, which might be even better. The carhop, cheerful and quick, packed the back with grocery bags and said, “‘Preciate ya!” with that familiar local warmth that makes the transaction feel more like a favor than a job. Made me smile more than I expected.There’s something solid about groceries in the trunk, even if I’m too tired to put them away right away. A pantry restocked is its own kind of comfort.

Wore out by early afternoon. Still, it’s a kind of satisfaction. Appointments handled, fridge fuller, pills lined up. Some days are built for maintenance.

Now, just watching the shadows stretch out, letting the day drift into night. Dinner plan: faux fried chicken salad tonight. Got the plant-based nugs in the freezer, the good kind that crisp up just right in the air fryer. Gotta remember to wash the lettuce before I forget again — it’s waiting in the crisper drawer like it always is, pretending to be invisible until dinner hour comes creeping up.

#quiettasks #roanokeva  #groceryrun #doctorvisit #doodle #frog

lone voice, steady drum

Downtown Roanoke, Williamson Road, just past noon — red light hanging overhead, the world paused for a breath.

And there she is.

One woman, one handmade sign, one American flag, standing at the corner like a lighthouse. Yellow board with words inked bold:

“RISE UP — CHANGE COURSE OF HISTORY — EVERYDAY PPL LIKE YOU + ME”

I do not know her name, but I know her rhythm. If I’m not mistaken, she’s led before — chants at the protests I’ve been to. A voice strong and sure, one we all follow when our own get tired. Today she stands alone, but not quietly. This is not silence — it’s signal.

People pass in cars, in buses, on foot. Some honk, some stare, some don’t see her at all. But she’s out there anyway, carrying her sign and flag, with the steady kind of presence that says: “I’m not here for the crowd. I’m here for the cause.”

You don’t always need thousands to start change. Sometimes one voice is the ember.
She’s awesome.

#Roanoke #EverydayHero #Protest

August 3rd, 2025 – late summer light filtering through the trees like golden syrup, slow and thick and a little sticky. A breeze now and then, enough to keep the bugs confused. One of those afternoons where the world feels paused between chapters.

🧶📚 We made our way to Dragon Bite Books, where the paperbacks lean in like old friends sharing secrets and the air smells like stories. Betty Grable, the shop cat, was very much on duty—zipping between shelves, brushing our legs with friendly purpose, pausing just long enough for a head bump before darting off to patrol her realm. Skittish, but sociable, like a librarian who’s short on time but still wants to say hello.

The take-home haul was a lovely one—some back issues of spinning magazines full of wooly dreams, a couple of gently-used novels, and a pleasing handful of art supplies. The wooden spheres clacked comfortingly in their little bag, the new stencil set looked ready to shape some fresh ideas, and the Halloween ribbon—orange and black plaid with a thin gold thread stitched through—caught the light in a way that felt like a wink from October. No pumpkins, no ghosts—just that subtle seasonal suggestion.

🐈‍⬛✨🎃

The Little Free Art Library was a bit bare today—just a bent paperclip and a sticker that said “You tried.” We tucked in three 3D printed llamas, all different sizes, ready to be adopted by passing hands. The kind of tiny thing that might make someone’s day brighter, or at least weirder in a good way.

We split a croissant from BreadCraft by the fountain, layers crisp and warm, little flakes tumbling into the water like edible confetti. A couple of pigeons watched us with obvious judgment. One tried to edge closer. We did not share.

Currently listening: the soft clack of wooden spheres and passing cicadas
Currently planning: what to stencil first
Currently grateful for: Betty Grable the shop cat, art surprises, and the quiet delight of orange and gold plaid

#scottobearstyle #salemva #dragonbitebooks #littlefreeartlibrary #3dprintedllamas #autumninspo #bookshopcat #breadcraftbreak

Game of life, pydroid v.2

import pygame
import pickle
import os
import copy

# — Configuration —
SCREEN_WIDTH, SCREEN_HEIGHT = 800, 600
CELL_SIZE = 10
GRID_WIDTH = SCREEN_WIDTH // CELL_SIZE
GRID_HEIGHT = (SCREEN_HEIGHT – 100) // CELL_SIZE # Reserve space for buttons

# Colors
COLOR_WHITE = (255, 255, 255)
COLOR_BLACK = (0, 0, 0)
COLOR_GRAY = (40, 40, 40)
COLOR_GREEN = (0, 255, 0)
COLOR_BLUE = (30, 144, 255)
COLOR_RED = (255, 69, 0)

# — Game of Life Logic (using standard lists) —
def create_grid(width, height):
    “””Creates a 2D list to represent the grid.”””
    return [[0 for _ in range(height)] for _ in range(width)]

def next_generation(grid):
    “””Computes the next generation of the grid based on the rules.”””
    width = len(grid)
    height = len(grid[0])
    new_grid = copy.deepcopy(grid) # Use deepcopy for lists of lists

    for x in range(width):
        for y in range(height):
            # Count live neighbors, handling wrapping at the edges (toroidal array)
            total = 0
            for i in range(-1, 2):
                for j in range(-1, 2):
                    if i == 0 and j == 0:
                        continue
                    # Calculate wrapped coordinates
                    nx, ny = (x + i) % width, (y + j) % height
                    total += grid[nx][ny]

            # Apply Conway’s rules
            if grid[x][y] == 1:
                if (total < 2) or (total > 3):
                    new_grid[x][y] = 0
            else:
                if total == 3:
                    new_grid[x][y] = 1
    return new_grid

# — Classic Patterns —
def get_patterns():
    “””Returns a dictionary of classic Game of Life patterns.”””
    patterns = {
        “Gosper Glider Gun”: [
            (5, 1), (5, 2), (6, 1), (6, 2), (5, 11), (6, 11), (7, 11),
            (4, 12), (8, 12), (3, 13), (9, 13), (3, 14), (9, 14), (6, 15),
            (4, 16), (8, 16), (5, 17), (6, 17), (7, 17), (6, 18),
            (3, 21), (4, 21), (5, 21), (3, 22), (4, 22), (5, 22),
            (2, 23), (6, 23), (1, 25), (2, 25), (6, 25), (7, 25),
            (3, 35), (4, 35), (3, 36), (4, 36)
        ],
        “Glider”: [(0, 1), (1, 2), (2, 0), (2, 1), (2, 2)],
        “Pulsar”: [
            (2,4),(3,4),(4,4),(8,4),(9,4),(10,4), (2,5),(7,5),(9,5),(14,5),
            (2,6),(7,6),(9,6),(14,6), (4,7),(5,7),(6,7),(10,7),(11,7),(12,7),
            (4,9),(5,9),(6,9),(10,9),(11,9),(12,9), (2,10),(7,10),(9,10),(14,10),
            (2,11),(7,11),(9,11),(14,11), (2,12),(3,12),(4,12),(8,12),(9,12),(10,12)
        ],
        “Clear”: []
    }
    return patterns

def place_pattern(grid, pattern_name, offset_x=10, offset_y=5):
    “””Places a pattern onto the grid.”””
    patterns = get_patterns()
    pattern = patterns.get(pattern_name)
    width = len(grid)
    height = len(grid[0])
   
    # Clear grid before placing pattern
    for x in range(width):
        for y in range(height):
            grid[x][y] = 0
           
    if pattern:
        for pos in pattern:
            # Ensure pattern fits on screen
            if 0 <= pos[0] + offset_x < width and 0 <= pos[1] + offset_y < height:
                grid[pos[0] + offset_x][pos[1] + offset_y] = 1

# — Pygame Setup —
pygame.init()
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
pygame.display.set_caption(“Conway’s Game of Life”)
clock = pygame.time.Clock()
font = pygame.font.SysFont(“sans”, 20)

# — Button Class —
class Button:
    def __init__(self, x, y, width, height, text, color):
        self.rect = pygame.Rect(x, y, width, height)
        self.text = text
        self.color = color

    def draw(self, surface):
        pygame.draw.rect(surface, self.color, self.rect)
        pygame.draw.rect(surface, COLOR_WHITE, self.rect, 2)
        text_surf = font.render(self.text, True, COLOR_WHITE)
        text_rect = text_surf.get_rect(center=self.rect.center)
        surface.blit(text_surf, text_rect)

    def is_clicked(self, pos):
        return self.rect.collidepoint(pos)

# — UI Elements —
buttons = {
    “play_pause”: Button(10, SCREEN_HEIGHT – 80, 100, 30, “Play”, COLOR_BLUE),
    “step”: Button(120, SCREEN_HEIGHT – 80, 70, 30, “Step”, COLOR_BLUE),
    “save”: Button(10, SCREEN_HEIGHT – 40, 70, 30, “Save”, COLOR_BLUE),
    “load”: Button(90, SCREEN_HEIGHT – 40, 70, 30, “Load”, COLOR_BLUE),
}
pattern_buttons = {}
pattern_names = list(get_patterns().keys())
x_offset = 200
for i, name in enumerate(pattern_names):
    pattern_buttons[name] = Button(x_offset + (i * 120), SCREEN_HEIGHT – 80, 110, 30, name, COLOR_GRAY)

# — Main Game Loop —
def main():
    grid = create_grid(GRID_WIDTH, GRID_HEIGHT)
    running = True
    paused = True
    drawing = False
    speed = 10  # Generations per second

    while running:
        for event in pygame.event.get():
            if event.type == pygame.QUIT: running = False
            if event.type == pygame.KEYDOWN and event.key == pygame.K_AC_BACK: running = False

            if event.type == pygame.MOUSEBUTTONDOWN:
                pos = pygame.mouse.get_pos()
                on_button = any(btn.is_clicked(pos) for btn in list(buttons.values()) + list(pattern_buttons.values()))

                if on_button:
                    # Handle UI buttons
                    if buttons[“play_pause”].is_clicked(pos):
                        paused = not paused
                        buttons[“play_pause”].text = “Play” if paused else “Pause”
                        buttons[“play_pause”].color = COLOR_BLUE if paused else COLOR_RED
                    elif buttons[“step”].is_clicked(pos) and paused:
                        grid = next_generation(grid)
                    elif buttons[“save”].is_clicked(pos):
                        try:
                            with open(“life_save.dat”, “wb”) as f:
                                pickle.dump(grid, f)
                            print(“Grid saved!”)
                        except Exception as e:
                            print(f”Error saving file: {e}”)
                    elif buttons[“load”].is_clicked(pos):
                        try:
                            if os.path.exists(“life_save.dat”):
                                with open(“life_save.dat”, “rb”) as f:
                                    grid = pickle.load(f)
                                print(“Grid loaded!”)
                        except Exception as e:
                            print(f”Error loading file: {e}”)
                   
                    for name, btn in pattern_buttons.items():
                        if btn.is_clicked(pos):
                            place_pattern(grid, name)
                else:
                    # Handle drawing on the grid
                    drawing = True
                    x, y = pos[0] // CELL_SIZE, pos[1] // CELL_SIZE
                    if 0 <= x < GRID_WIDTH and 0 <= y < GRID_HEIGHT:
                        grid[x][y] = 1 – grid[x][y] # Toggle cell

            if event.type == pygame.MOUSEBUTTONUP:
                drawing = False

            if event.type == pygame.MOUSEMOTION and drawing:
                pos = pygame.mouse.get_pos()
                x, y = pos[0] // CELL_SIZE, pos[1] // CELL_SIZE
                if 0 <= x < GRID_WIDTH and 0 <= y < GRID_HEIGHT:
                    grid[x][y] = 1 # Draw live cells

        if not paused:
            grid = next_generation(grid)

        # — Drawing —
        screen.fill(COLOR_BLACK)
        for x in range(GRID_WIDTH):
            for y in range(GRID_HEIGHT):
                if grid[x][y] == 1:
                    pygame.draw.rect(screen, COLOR_GREEN, (x*CELL_SIZE, y*CELL_SIZE, CELL_SIZE, CELL_SIZE))
                pygame.draw.rect(screen, COLOR_GRAY, (x*CELL_SIZE, y*CELL_SIZE, CELL_SIZE, CELL_SIZE), 1)

        pygame.draw.rect(screen, (50,50,50), (0, SCREEN_HEIGHT – 100, SCREEN_WIDTH, 100))
        for btn in buttons.values():
            btn.draw(screen)
        for btn in pattern_buttons.values():
            btn.draw(screen)
       
        pygame.display.flip()
        clock.tick(speed)

    pygame.quit()

if __name__ == ‘__main__’:
    main()

Animal game v.2 with gui

import tkinter as tk
from tkinter import simpledialog, messagebox
import pickle
import os

class Node:
    def __init__(self, question=None, animal=None):
        self.question = question
        self.animal = animal
        self.yes = None
        self.no = None

    def is_leaf(self):
        return self.animal is not None

class AnimalGuesserApp:
    def __init__(self, master):
        self.master = master
        self.master.title(“Animal Guesser”)
        self.master.geometry(“500×300”)
        self.master.option_add(“*Font”, “Arial 16”)

        self.label = tk.Message(master, text=””, width=460)
        self.label.pack(pady=30)

        btn_frame = tk.Frame(master)
        btn_frame.pack()

        self.yes_button = tk.Button(btn_frame, text=”Yes”, width=10, command=self.handle_yes)
        self.no_button = tk.Button(btn_frame, text=”No”, width=10, command=self.handle_no)

        self.yes_button.pack(side=”left”, padx=20)
        self.no_button.pack(side=”right”, padx=20)

        self.tree = self.load_tree()
        self.current_node = self.tree
        self.parent_stack = []  # Track the path for updating
        self.mode = “ask”  # ask / learn / done

        self.display_current()

    def display_current(self):
        if self.current_node.is_leaf():
            self.label.config(text=f”Is it a {self.current_node.animal}?”)
            self.mode = “guess”
        else:
            self.label.config(text=self.current_node.question)
            self.mode = “ask”

    def handle_yes(self):
        if self.mode == “ask”:
            self.parent_stack.append((self.current_node, True))
            self.current_node = self.current_node.yes
            self.display_current()

        elif self.mode == “guess”:
            self.label.config(text=”Yay! I guessed it!\nPlay again?”)
            self.mode = “done”

        elif self.mode == “done”:
            self.reset_game()

        elif self.mode == “learn_step2”:
            # user answered yes to: “for the new animal, what’s the answer?”
            self.insert_new_knowledge(True)

    def handle_no(self):
        if self.mode == “ask”:
            self.parent_stack.append((self.current_node, False))
            self.current_node = self.current_node.no
            self.display_current()

        elif self.mode == “guess”:
            self.start_learning()

        elif self.mode == “done”:
            self.master.quit()

        elif self.mode == “learn_step2”:
            # user answered no to: “for the new animal, what’s the answer?”
            self.insert_new_knowledge(False)

    def start_learning(self):
        self.new_animal = simpledialog.askstring(“Teach me”, “I give up! What animal were you thinking of?”)
        if not self.new_animal:
            self.label.config(text=”Okay, I’ll try better next time.\nPlay again?”)
            self.mode = “done”
            return

        self.new_question = simpledialog.askstring(“Help me learn”, f”Give me a yes/no question to tell a {self.new_animal} from a {self.current_node.animal}”)
        if not self.new_question:
            self.label.config(text=”No worries. Want to play again?”)
            self.mode = “done”
            return

        self.label.config(text=f”For a {self.new_animal}, what is the answer to your question?”)
        self.mode = “learn_step2”

    def insert_new_knowledge(self, new_animal_answer_yes):
        new_node = Node(question=self.new_question)
        if new_animal_answer_yes:
            new_node.yes = Node(animal=self.new_animal)
            new_node.no = self.current_node
        else:
            new_node.no = Node(animal=self.new_animal)
            new_node.yes = self.current_node

        # Attach new node to parent
        if self.parent_stack:
            parent, went_yes = self.parent_stack[-1]
            if went_yes:
                parent.yes = new_node
            else:
                parent.no = new_node
        else:
            self.tree = new_node  # Root replaced

        self.save_tree()
        self.label.config(text=”Thanks! I’ve learned something new.\nPlay again?”)
        self.mode = “done”

    def reset_game(self):
        self.current_node = self.tree
        self.parent_stack = []
        self.display_current()

    def save_tree(self, filename=”animal_tree.pkl”):
        with open(filename, “wb”) as f:
            pickle.dump(self.tree, f)

    def load_tree(self, filename=”animal_tree.pkl”):
        if os.path.exists(filename):
            with open(filename, “rb”) as f:
                return pickle.load(f)
        else:
            return Node(animal=”cat”)

if __name__ == “__main__”:
    root = tk.Tk()
    app = AnimalGuesserApp(root)
    root.mainloop()

import pickle
import os

class Node:
    def __init__(self, question=None, animal=None):
        self.question = question
        self.animal = animal
        self.yes = None
        self.no = None

    def is_leaf(self):
        return self.animal is not None

def ask_yes_no(prompt):
    while True:
        ans = input(prompt + ” (y/n): “).strip().lower()
        if ans in [‘y’, ‘yes’]:
            return True
        elif ans in [‘n’, ‘no’]:
            return False
        print(“Please enter y or n.”)

def play(node):
    if node.is_leaf():
        if ask_yes_no(f”Is it a {node.animal}?”):
            print(“Yay! I guessed it!”)
            return node
        else:
            return learn(node)
    else:
        if ask_yes_no(node.question):
            node.yes = play(node.yes)
        else:
            node.no = play(node.no)
        return node

def learn(old_node):
    new_animal = input(“I give up! What animal were you thinking of? “).strip()
    question = input(f”Give me a yes/no question to tell a {new_animal} from a {old_node.animal}: “).strip()
    if ask_yes_no(f”For a {new_animal}, what is the answer to your question?”):
        new_node = Node(question=question)
        new_node.yes = Node(animal=new_animal)
        new_node.no = old_node
    else:
        new_node = Node(question=question)
        new_node.no = Node(animal=new_animal)
        new_node.yes = old_node
    print(“Thanks! I’ll remember that.”)
    return new_node

def save_tree(tree, filename=”animal_tree.pkl”):
    with open(filename, “wb”) as f:
        pickle.dump(tree, f)

def load_tree(filename=”animal_tree.pkl”):
    if os.path.exists(filename):
        with open(filename, “rb”) as f:
            return pickle.load(f)
    else:
        # Start with a default animal
        return Node(animal=”cat”)

def main():
    print(“Think of an animal, and I’ll try to guess it!”)
    tree = load_tree()
    tree = play(tree)
    save_tree(tree)

if __name__ == “__main__”:
    while True:
        main()
        if not ask_yes_no(“Play again?”):
            break

Bat flying test pydroid

import pygame
import math
import sys

# Initialize Pygame
pygame.init()

# Set screen size
WIDTH, HEIGHT = 800, 600
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption(“Flying Bat”)

clock = pygame.time.Clock()

# Bat position
x = 0
y = HEIGHT // 2

# Wing flap variables
wing_angle = 0
flap_speed = 0.15

# Colors
BLACK = (0, 0, 0)
DARK_GREY = (50, 50, 50)
WHITE = (255, 255, 255)

def draw_bat(surface, x, y, angle):
    body_width = 40
    body_height = 20

    # Draw bat body
    pygame.draw.ellipse(surface, DARK_GREY, (x, y, body_width, body_height))

    # Left wing
    left_points = [
        (x + 10, y + 10),
        (x – 30, y – 10 – int(math.sin(angle) * 20)),
        (x – 10, y + 10),
    ]
    pygame.draw.polygon(surface, DARK_GREY, left_points)

    # Right wing
    right_points = [
        (x + 30, y + 10),
        (x + 70, y – 10 – int(math.sin(angle) * 20)),
        (x + 50, y + 10),
    ]
    pygame.draw.polygon(surface, DARK_GREY, right_points)

# Main loop
running = True
while running:
    screen.fill(BLACK)

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    # Animate
    wing_angle += flap_speed
    x += 3
    if x > WIDTH:
        x = -60  # Reset when offscreen

    draw_bat(screen, x, y + int(math.sin(wing_angle) * 10), wing_angle)

    pygame.display.flip()
    clock.tick(60)

pygame.quit()
sys.exit()

Friday draped in haze, wearing its quiet like a loose shirt.

Waited this morning from 10 to noon for a crew that never came. The kind of waiting where you second-guess every sound outside — leaf blower? delivery? redemption? — and end up just pacing and rereading the same sentence three times. Gave up eventually, but not before having a small conversation with a squirrel on the fence. He seemed equally unimpressed by the lack of progress.

Once free of obligation, wandered a while. Took the back way through the trees where the ground still holds last night’s rain, and the mushrooms are staging their slow uprising. One looked like a tiny red umbrella, forgotten by a fairy with better things to do. Passed someone walking two dogs — one anxious, one confident — a duo that reminded me of most of my decision-making process.

Drew for a bit this afternoon. Nothing profound — just lines and loops, loose shapes turning into something vaguely owl-like. Or maybe a spaceship. Sometimes it’s better not to know what it is while it’s still becoming.

Saw a fox print in the mud, sharp and fresh. No fox in sight, just the echo of movement. That felt about right for today — evidence of life passing by, quietly, while you’re looking the other way.

Tonight? Windows cracked open, low hum of crickets tuning up for their set. Might read, might not. Might just sit still and let the dark arrive on its own time.

No grand revelations. Just breath, breeze, and a sense that things are still turning, even when you’re paused.