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.

thick heat & hazy gold light

Woke up late, which isn’t usual, but maybe necessary. The air was already syrupy with warmth, pressing in through the windows before I’d even had a sip of coffee. Sat with the fan buzzing like a lazy hornet, flipping through a dog-eared field guide of native plants. There’s comfort in names—sweetspire, ironweed, bloodroot—like knowing the password to the green parts of the world.

Walked a slow loop in the early afternoon. The shade was a mercy. Dragonflies hovered like living stitches over puddles that hadn’t fully surrendered to the sun. Heard a woodpecker knocking at something deep in the trees—each tap like a code I couldn’t quite translate.

Pulled a single rune today: Laguz — water, intuition, the hidden current.
Fitting. Everything today felt submerged, like looking at life through a murky lens. Not unpleasant, just… deeper. Like something’s stirring below the surface.

Listened to an old radio drama while sorting through laundry in my closet.  One of those crackly, noir-voiced tales full of long shadows and double-crosses. Felt strangely comforting. The kind of story where nobody’s innocent but someone always tries to do right, even if it’s messy.

Dinner was roasted vegetables, chilled white bean salad, a chunk of bread big enough to be dangerous. Kept it simple. Let the quiet fill the space.

Now the cicadas are singing their electric hymn outside, and the sky’s starting to bruise at the edges. Might write a letter I’ll never send. Might just sit and listen.

🌒 Let the tide carry you, dear journal

Woke up to the thrum of cicadas and the soft hush of gray cloud cover. Felt like the kind of day where the world takes a breath and holds it. Grabbed a can of diet orange vanilla coke, watched the cold mist curl out like old ghost stories, and wandered out for a morning walk along the Roanoke Greenway. Damp earth, mossy edges, and that sweet loamy scent of things growing just out of sight. One crow called out from a telephone wire and another answered across the river. Not sure if they were arguing or conspiring, but it felt important.

A quiet sense of being observed all day—not in a paranoid way, but like the trees were noting my presence. Probably just the caffeine and overactive imagination playing tag.

Read a few pages from a pulp horror zine someone left in the free little library—ink smudged, cover half torn, but perfect in its way. Story was about a sentient fog that eats memories. Kept thinking about that all afternoon. What would it take to let go of a memory willingly?

Dinner was black beans, hot sauce, and a grilled plantain. Simple. Good. Enough.

Thinking about making a zine of my own again, but its more likely I’ll just stitch words together here and let them drift.

Signing off with the window open and the hope for a thunderstorm to roll in and rattle the bones of the house.

Until later, dear journal.

Runes and i ching robot, v0.2 , still building interpretation code for blog.

Output should include rune & i Ching, possibly a one line summary.

May merge in the tarot too?

import tkinter as tk
import random
from datetime import datetime

# Elder Futhark Runes with meanings
runes = [
    (“Fehu”, “Wealth, prosperity”),
    (“Uruz”, “Strength, health”),
    (“Thurisaz”, “Conflict, protection”),
    (“Ansuz”, “Communication, insight”),
    (“Raidho”, “Journey, travel”),
    (“Kenaz”, “Knowledge, creativity”),
    (“Gebo”, “Gift, generosity”),
    (“Wunjo”, “Joy, harmony”),
    (“Hagalaz”, “Disruption, hail”),
    (“Nauthiz”, “Need, resistance”),
    (“Isa”, “Stillness, ice”),
    (“Jera”, “Harvest, reward”),
    (“Eihwaz”, “Endurance, transformation”),
    (“Perthro”, “Mystery, fate”),
    (“Algiz”, “Protection, higher self”),
    (“Sowilo”, “Success, vitality”),
    (“Tiwaz”, “Justice, leadership”),
    (“Berkano”, “Birth, growth”),
    (“Ehwaz”, “Movement, change”),
    (“Mannaz”, “Humanity, cooperation”),
    (“Laguz”, “Flow, intuition”),
    (“Ingwaz”, “Fertility, potential”),
    (“Dagaz”, “Breakthrough, awakening”),
    (“Othala”, “Heritage, inheritance”)
]

# I Ching full 64 hexagrams
hexagrams = {
    “111111”: (1, “Creative Force”),
    “000000”: (2, “Receptive Earth”),
    “100010”: (3, “Difficulty at the Beginning”),
    “010001”: (4, “Youthful Folly”),
    “111010”: (5, “Waiting”),
    “010111”: (6, “Conflict”),
    “010000”: (7, “The Army”),
    “000010”: (8, “Holding Together”),
    “111011”: (9, “Taming the Power of the Small”),
    “110111”: (10, “Treading”),
    “111000”: (11, “Peace”),
    “000111”: (12, “Standstill”),
    “101111”: (13, “Fellowship with Men”),
    “111101”: (14, “Great Possession”),
    “001000”: (15, “Modesty”),
    “000100”: (16, “Enthusiasm”),
    “100110”: (17, “Following”),
    “011001”: (18, “Work on the Decayed”),
    “110000”: (19, “Approach”),
    “000011”: (20, “Contemplation”),
    “100101”: (21, “Biting Through”),
    “101001”: (22, “Grace”),
    “000001”: (23, “Splitting Apart”),
    “100000”: (24, “Return”),
    “100111”: (25, “Innocence”),
    “111001”: (26, “Great Taming”),
    “100001”: (27, “Nourishment”),
    “011110”: (28, “Great Exceeding”),
    “010010”: (29, “Danger”),
    “101101”: (30, “Clinging Fire”),
    “001110”: (31, “Influence”),
    “011100”: (32, “Endurance”),
    “001111”: (33, “Retreat”),
    “111100”: (34, “Great Power”),
    “000101”: (35, “Progress”),
    “101000”: (36, “Darkening of the Light”),
    “101011”: (37, “Family”),
    “110101”: (38, “Opposition”),
    “001010”: (39, “Obstruction”),
    “010100”: (40, “Deliverance”),
    “110001”: (41, “Decrease”),
    “100011”: (42, “Increase”),
    “111110”: (43, “Breakthrough”),
    “011111”: (44, “Coming to Meet”),
    “000110”: (45, “Gathering Together”),
    “011000”: (46, “Pushing Upward”),
    “010110”: (47, “Oppression”),
    “011010”: (48, “The Well”),
    “101110”: (49, “Revolution”),
    “011101”: (50, “The Cauldron”),
    “100100”: (51, “The Arousing”),
    “001001”: (52, “Keeping Still”),
    “001011”: (53, “Gradual Progress”),
    “110100”: (54, “Marrying Maiden”),
    “101100”: (55, “Abundance”),
    “001101”: (56, “The Wanderer”),
    “011011”: (57, “Gentle Wind”),
    “110110”: (58, “Joyous Lake”),
    “010011”: (59, “Dispersion”),
    “110010”: (60, “Limitation”),
    “110011”: (61, “Inner Truth”),
    “001100”: (62, “Small Exceeding”),
    “101010”: (63, “After Completion”),
    “010101”: (64, “Before Completion”)
}

def cast_runes():
    non_reversing = {“Gebo”, “Hagalaz”, “Isa”, “Jera”, “Sowilo”, “Dagaz”, “Ingwaz”}
    chosen = random.sample(runes, 3)
    result = []
    for name, meaning in chosen:
        if name in non_reversing:
            result.append((name, meaning))
        else:
            reversed_flag = random.choice([True, False])
            if reversed_flag:
                result.append((f”{name} (reversed)”, f”Blocked or inverted: {meaning}”))
            else:
                result.append((name, meaning))
    return result

def cast_i_ching():
    lines = []
    binary = “”
    for _ in range(6):
        tosses = [random.choice([2, 3]) for _ in range(3)]
        total = sum(tosses)
        if total == 6:
            lines.append(“Old Yin (6) – changing to Yang”)
            binary = “0” + binary
        elif total == 7:
            lines.append(“Young Yang (7)”)
            binary = “1” + binary
        elif total == 8:
            lines.append(“Young Yin (8)”)
            binary = “0” + binary
        elif total == 9:
            lines.append(“Old Yang (9) – changing to Yin”)
            binary = “1” + binary
    hex_info = hexagrams.get(binary, (“?”, “Unknown Hexagram”))
    return lines[::-1], hex_info

def days_since_birth():
    return (datetime.today() – datetime(1969, 2, 2)).days

def cast_all():
    rune_results = cast_runes()
    i_ching_lines, (hex_num, hex_name) = cast_i_ching()
    days = days_since_birth()

    output_text = “Runes Drawn:\n”
    for i, (name, meaning) in enumerate(rune_results, 1):
        output_text += f” {i}. {name} – {meaning}\n”

    output_text += “\nI Ching Hexagram (bottom to top):\n”
    for line in i_ching_lines:
        output_text += f” – {line}\n”
    output_text += f”\nHexagram #{hex_num}: {hex_name}\n”
    output_text += f”\nDays since Feb 2, 1969: {days} days”

    output.delete(“1.0”, tk.END)
    output.insert(tk.END, output_text)
    cast_all.result_text = output_text

def share_result():
    try:
        root.clipboard_clear()
        root.clipboard_append(cast_all.result_text)
        root.update()
        status_label.config(text=”Copied to clipboard!”)
    except:
        status_label.config(text=”Copy failed”)

# GUI setup (night mode)
root = tk.Tk()
root.title(“Runes & I Ching”)
root.configure(bg=”#1a1a1a”)
root.geometry(“380×640”)

title = tk.Label(root, text=”Rune & I Ching Caster”, font=(“Helvetica”, 16, “bold”), bg=”#1a1a1a”, fg=”white”)
title.pack(pady=10)

cast_button = tk.Button(root, text=”Cast Runes + I Ching”, command=cast_all, font=(“Helvetica”, 13),
                        bg=”#333″, fg=”white”)
cast_button.pack(pady=5)

share_button = tk.Button(root, text=”Share Results”, command=share_result, font=(“Helvetica”, 13),
                         bg=”#555″, fg=”white”)
share_button.pack(pady=5)

output = tk.Text(root, height=26, width=44, font=(“Courier”, 10), wrap=”word”,
                 bg=”#121212″, fg=”#dddddd”, insertbackground=”white”)
output.pack(padx=10, pady=10)

status_label = tk.Label(root, text=””, font=(“Helvetica”, 10), bg=”#1a1a1a”, fg=”#00cc99″)
status_label.pack()

cast_all.result_text = “”

root.mainloop()

Some runes cannot be reversed

Gebo (ᚷ)
Hagalaz (ᚺ)
Isa (ᛁ)
Jera (ᛃ)
Sowilo (ᛋ)
Dagaz (ᛞ)
Ingwaz (ᛜ)

So the fixed cast_runes code is –

def cast_runes():
    non_reversing = {“Gebo”, “Hagalaz”, “Isa”, “Jera”, “Sowilo”, “Dagaz”, “Ingwaz”}
    chosen = random.sample(runes, 3)
    result = []
    for name, meaning in chosen:
        if name in non_reversing:
            result.append((name, meaning))
        else:
            reversed_flag = random.choice([True, False])
            if reversed_flag:
                result.append((f”{name} (reversed)”, f”Blocked or inverted: {meaning}”))
            else:
                result.append((name, meaning))
    return result

streaming Netflix in HD for 4 hours uses approximately 200 liters of water. This figure includes the water used in data centers to cool servers and in the production of the electricity used to power those servers

https://energy.mit.edu/news/how-can-you-reduce-the-environmental-impact-of-your-next-virtual-meeting/#:~:text=One%20hour%20of%20streaming%20or,size%20of%20an%20iPad%20Mini.

Texas ai is a mess too

https://techiegamers.com/texas-data-centers-quietly-draining-water/

Clouds hung low over Catawba, like forgotten curtains in a theater that only stages quiet moments. The day unfurled at a thoughtful pace, no rush, no roar. Breakfast of maple oatmeal was good. Reliable. Like a friend who doesn’t ask questions but always shows up.

Working a bit more on the scrying app.  Glyphs rotate with slow intent, echoing Appalachian sigils that seem more felt than seen. The code behaved, mostly, as if the machine sensed it was being part of something more poetic than practical. There’s a rhythm in spinning shapes that speaks to something older than syntax.

Outside, nature offered scattered commentary: crows debating, trees nodding, humidity wrapping everything like a soft quilt. No omens, just ambiance.

Ended the day tangled in thought, wondering whether folklore knows it’s being reimagined daily. Probably doesn’t mind.

import random

# === TAROT DECK DEFINITIONS ===

major_arcana = {
    “The Fool”: (“Beginnings, innocence, spontaneity”, “Recklessness, naivety”),
    “The Magician”: (“Manifestation, resourcefulness”, “Manipulation, deception”),
    “The High Priestess”: (“Intuition, mystery”, “Hidden motives, ignoring intuition”),
    “The Empress”: (“Fertility, nurturing”, “Dependency, creative blocks”),
    “The Emperor”: (“Authority, structure”, “Tyranny, rigidity”),
    “The Hierophant”: (“Tradition, learning”, “Rebellion, nonconformity”),
    “The Lovers”: (“Love, harmony, union”, “Disharmony, imbalance”),
    “The Chariot”: (“Willpower, victory”, “Lack of direction”),
    “Strength”: (“Courage, compassion”, “Doubt, insecurity”),
    “The Hermit”: (“Introspection, solitude”, “Isolation, withdrawal”),
    “Wheel of Fortune”: (“Luck, destiny”, “Resistance to change”),
    “Justice”: (“Truth, fairness”, “Injustice, dishonesty”),
    “The Hanged Man”: (“Letting go, perspective”, “Stalling, martyrdom”),
    “Death”: (“Endings, transformation”, “Resistance to change”),
    “Temperance”: (“Balance, moderation”, “Excess, imbalance”),
    “The Devil”: (“Addiction, materialism”, “Freedom, release”),
    “The Tower”: (“Sudden change, upheaval”, “Avoiding disaster”),
    “The Star”: (“Hope, renewal”, “Despair, lack of faith”),
    “The Moon”: (“Illusion, intuition”, “Confusion, clarity”),
    “The Sun”: (“Joy, success”, “Negativity, sadness”),
    “Judgement”: (“Reflection, rebirth”, “Guilt, refusal to change”),
    “The World”: (“Completion, achievement”, “Lack of closure”)
}

suits = {
    “Cups”: “Emotions, relationships”,
    “Pentacles”: “Material, work, finances”,
    “Swords”: “Thought, conflict, logic”,
    “Wands”: “Action, creativity, passion”
}

ranks = {
    “Ace”: (“New beginnings in”, “Blocked energy in”),
    “Two”: (“Balance and partnership in”, “Imbalance and indecision in”),
    “Three”: (“Growth and collaboration in”, “Miscommunication or delay in”),
    “Four”: (“Stability and rest in”, “Stagnation or boredom in”),
    “Five”: (“Conflict and change in”, “Recovery or resolution in”),
    “Six”: (“Harmony and support in”, “Lack of help or imbalance in”),
    “Seven”: (“Challenges and perseverance in”, “Giving up or overwhelm in”),
    “Eight”: (“Movement and focus in”, “Distraction or lack of direction in”),
    “Nine”: (“Fulfillment and satisfaction in”, “Overindulgence or dissatisfaction in”),
    “Ten”: (“Completion and legacy in”, “Burden or burnout in”),
    “Page”: (“Curiosity and new ideas in”, “Immaturity or distraction in”),
    “Knight”: (“Action and pursuit in”, “Recklessness or inaction in”),
    “Queen”: (“Maturity and nurturing in”, “Coldness or dependence in”),
    “King”: (“Mastery and leadership in”, “Control issues or arrogance in”)
}

# === DECK CREATION ===

def build_tarot_deck():
    deck = {}
    for name, meanings in major_arcana.items():
        deck[name] = {“upright”: meanings[0], “reversed”: meanings[1]}
    for suit, theme in suits.items():
        for rank, meanings in ranks.items():
            card = f”{rank} of {suit}”
            up = f”{meanings[0]} {theme.lower()}”
            rev = f”{meanings[1]} {theme.lower()}”
            deck[card] = {“upright”: up, “reversed”: rev}
    return deck

def draw_card(deck):
    card = random.choice(list(deck.keys()))
    is_rev = random.choice([True, False])
    orientation = “Reversed” if is_rev else “Upright”
    meaning = deck[card][“reversed” if is_rev else “upright”]
    return card, orientation, meaning

# === FORMATTING OPTIONS ===

def format_plain(title, entries):
    out = f”{title}\n\n”
    for label, card, orient, meaning in entries:
        out += f”{label}: {card} ({orient})\nMeaning: {meaning}\n\n”
    return out.strip()

def format_blog(title, entries):
    out = f”## {title}\n\n”
    for label, card, orient, meaning in entries:
        out += f”**{label}: {card}** *({orient})*\n→ {meaning}\n\n”
    return out.strip()

def format_bluesky(title, entries):
    lines = [f”{title} 🔮”]
    for label, card, orient, meaning in entries:
        short = meaning.split(“,”)[0].strip()
        emoji = “🌞” if orient == “Upright” else “🌒”
        lines.append(f”{label}: {card} {emoji} — {short}”)
    lines.append(“#Tarot #Divination #CelticCross” if “Celtic” in title else “#TarotReading #3CardSpread”)
    return “\n”.join(lines)

def share_output(title, entries):
    print(“\nChoose format:”)
    print(“1. Plain”)
    print(“2. Blog”)
    print(“3. Bluesky”)
    style = input(“Select (1–3): “).strip()

    if style == “2”:
        output = format_blog(title, entries)
    elif style == “3”:
        output = format_bluesky(title, entries)
    else:
        output = format_plain(title, entries)

    print(“\n>>> COPY BELOW >>>\n”)
    print(output)
    print(“\n<<< END <<<“)

# === SPREADS ===

def three_card_spread(deck):
    labels = [“Past”, “Present”, “Future”]
    entries = []
    for label in labels:
        card, orient, meaning = draw_card(deck)
        entries.append((label, card, orient, meaning))
    share_output(“3-Card Tarot Spread”, entries)

def celtic_cross_spread(deck):
    positions = [
        “1. Present Situation”,
        “2. Immediate Challenge”,
        “3. Subconscious Influence”,
        “4. Past Influence”,
        “5. Conscious Goal”,
        “6. Near Future”,
        “7. Self / Attitude”,
        “8. Environment”,
        “9. Hopes & Fears”,
        “10. Final Outcome”
    ]
    used = set()
    entries = []
    for label in positions:
        while True:
            card, orient, meaning = draw_card(deck)
            if card not in used:
                used.add(card)
                entries.append((label, card, orient, meaning))
                break
    share_output(“Celtic Cross Spread”, entries)

# === MAIN ===

def main():
    tarot = build_tarot_deck()
    print(“=== Tarot Divination ===”)
    print(“1. 3-Card Spread”)
    print(“2. Celtic Cross Spread”)
    choice = input(“Choose your spread (1 or 2): “).strip()
    if choice == “1”:
        three_card_spread(tarot)
    elif choice == “2”:
        celtic_cross_spread(tarot)
    else:
        print(“Invalid input. Try again.”)

if __name__ == “__main__”:
    main()