Forem: Chris Greening

Documentation That Builds Itself with Sphinx + Read the Docs

Chris Greening — Fri, 18 Apr 2025 13:00:00 +0000

What if your documentation built itself?

With the latest update to Greening, it kind of does.

🌿 Docs with Zero Effort

When you run:

greening new

Greening now automatically scaffolds a complete Sphinx documentation setup right alongside your project.

That includes:

A fully wired docs/ directory
Smart conf.py configuration with your project name, slug, author, and version
Automatic API reference generation using autodoc and autosummary
Recursive scanning of your codebase
The clean and familiar Read the Docs theme

All of this is driven directly from your greening.yaml — no manual setup required.

🚀 Instant Hosting with Read the Docs

Once your project is pushed to GitHub, all you have to do is:

Go to readthedocs.org
Link your GitHub repo
✅ Done

Read the Docs will:

Automatically detect your docs/ folder
Install any dependencies listed in requirements.txt
Build your documentation from your actual code
Rebuild it every time you push to main

Your code is documented. Your documentation is hosted. Everything just works.

Summary

No need for extra steps or boilerplate.

Just run:

greening init
greening new

And your project ships with full developer-facing docs, automatically generated and deployed with zero extra effort.

Because documentation should be part of the build, not a separate to-do list.

GitHub Autodetection Comes to Greening

Chris Greening — Mon, 14 Apr 2025 16:00:00 +0000

Tired of typing your GitHub username for the hundredth time?

We were too.

Greening now automatically detects your GitHub username and email from your local Git configuration, and intelligently sets up your project YAML based on whether you’ve authenticated with a GITHUB_TOKEN.

This small change adds up to a much smoother “greening init” experience , with fewer fields to fill out and fewer reasons to stall when inspiration hits.

How It Works

When you run:

greening init

Greening now looks for:

git config user.name
git config user.email

If found, it pre-fills those values in greening.yaml. No need to remember your GitHub handle, no need to copy-paste your email again.

But it goes one step further…

If you’ve already set a GITHUB_TOKEN in your environment (to allow GitHub repo creation), Greening assumes you want automation mode engaged.

So instead of prompting you to manually fill out a git_remote, it will:

Autocomment the git_remote: line
Uncomment and set create_github_repo: true

This means when you run:

greening new

You’ll get a fully scaffolded project , GitHub repo automatically created , and everything pushed in seconds — all without editing a single config field.

Why We Did This

The philosophy behind Greening has always been:

If you’ve done it more than twice, Greening should probably do it for you.

Even tiny points of friction — like having to setup a GitHub repo — can break flow. And we’re obsessed with keeping you in flow.

Every saved keystroke, every reduced prompt, every automated step is another seed planted toward a finished project.

What’s Next

We’re actively working on a plugin system , smarter defaults, and automatic detection for even more fields. Because the less you have to think about setup, the more you can focus on building.

Try it out. Set your GitHub token, run greening init, and just build.

📌 Greening on GitHub

pip install greening

🌱 New Feature: Beautiful Per-Command Help for the Greening CLI

Chris Greening — Wed, 09 Apr 2025 16:00:00 +0000

🌿 One of the newest additions to the Greening CLI is intuitive, per-command help. You can now run:

greening <command> --help

greening help <command>

To instantly get detailed, actionable help for that specific command — no guesswork, no flipping to the docs mid-flow.

🌱 How It Works

Let’s say you want to scaffold a new project. Just type:

greening new --help

and you'll see:

Usage: greening new [OPTIONS]

Scaffold a new Python project using greening.yaml.

This command uses your greening.yaml configuration to generate a full project structure based on a customizable template.
It can also automatically:
- Initialize a GitHub repository
- Create and activate a virtual environment
- Commit and push the project to GitHub

Options:
  --help              Show this message and exit.

Examples:
  greening new

Ready to deploy a fully scaffolded GitHub Pages site with Jekyll?

greening deploy --help

Returns:

Usage: greening deploy [OPTIONS]

Deploy a documentation site using GitHub Pages.

This command generates and deploys a Jekyll site (using the Minimal Mistakes theme) based on your project metadata in greening.yaml.

It can also:
- Automatically push the site to the `gh-pages` branch of your GitHub repository
- Auto-configure Google Analytics if a tracking ID is defined in greening.yaml

Options:
  --help              Show this help message and exit

Examples:
  greening deploy

Want to initialize your config?

greening init --help

Outputs:

Usage: greening init

Initialize a new greening.yaml config file in the current directory.

This command inspects your environment and Git configuration to prepopulate sensible defaults:
- Auto-detects your GitHub username and email via git config
- Checks for a GITHUB_TOKEN in your environment
- Creates greening.yaml only if one does not already exist

Options:
  --help              Show this help message and exit

Examples:
  greening init

🌾 Why This Matters

Greening is all about eliminating friction and helping you ship beautiful software fast. With these new help commands, you can:

🌱 Stay in flow
🌿 Learn Greening’s capabilities organically
🌾 Discover hidden features you might’ve missed

You don’t need to remember everything. You just need to remember:

greening <command> --help

🌱 What’s Next?

As new features roll out, each command’s help will grow to reflect new flags, options, and workflows. All discoverable in the CLI — no context switching, no fluff.

Stay tuned — and keep planting those seeds. 🌿

How to Generate a GitHub Token for Pushing Repos with Greening

Chris Greening — Mon, 07 Apr 2025 16:00:00 +0000

When using greening new to auto-create and push a repo to GitHub, you'll need a GitHub token with proper permissions. This token allows Greening to authenticate with the GitHub API on your behalf and create new repositories for your projects.

Chris Greening - Software Developer

Hey! My name's Chris Greening and I'm a software developer from the New York metro area with a diverse range of engineering experience - beam me a message and let's build something great!

christophergreening.com

Here’s how to generate one and use it securely:

🔐 Step 1: Generate a New Token

Visit github.com/settings/tokens
Click "Generate new token"
Use the following settings:
- Note: Greening CLI access
- Expiration: Choose one (90 days or custom)
- Scopes: Check the box for:
  - repo (Full control of private repositories)
Click "Generate token" and copy it immediately.

🧠 Step 2: Add It to Your Environment

For security, never hard-code your token into your project.

Instead, add it to your environment using one of the following:

Unix/macOS

export GITHUB_TOKEN=ghp_your_token_here

You can also add this to your ~/.bashrc, ~/.zshrc, or ~/.bash_profile.

Windows (Command Prompt)

set GITHUB_TOKEN=ghp_your_token_here

Windows (PowerShell)

$env:GITHUB_TOKEN = "ghp_your_token_here"

✅ Step 3: Use It with Greening

Now that your token is available, Greening will detect it automatically.

Just run:

greening new

If you have create_github_repo: true in your greening.yaml config, Greening will:

Create a new GitHub repo
Add the remote
Push your project

No extra steps. ✨

🧼 Bonus: Keeping Your Token Safe

Don’t commit .env files or shell profiles to public repos.
Rotate your token periodically, especially if it becomes exposed.
Use fine-grained tokens for more control (GitHub now supports these).

Greening aims to make shipping your ideas painless — and this is a big part of that. By setting up your token once, you’ll unlock powerful automation across every new project.

Happy shipping 🌱

—

Got questions? Open an issue or join the discussion at

chris-greening / greening

greening is an opinionated, lightweight project automation tool for solo developers and creative coders. With just a few commands, you can scaffold a production-ready Python package — complete with docs, tests, GitHub Actions workflows, PyPI packaging, and an auto-deployed GitHub Pages site. No boilerplate. No setup hell. Just instant polish.

🌱 Greening

greening is an opinionated, full-stack Project as Code automation tool for solo developers and creative coders.

With just a few commands, you can scaffold a production-ready Python package complete with docs, tests, GitHub Actions workflows, PyPI packaging, and an auto-deployed GitHub Pages site No boilerplate or setup hell, just instant polish.

🍃 Why `greening`?

Most devs never ship their tools. Not because the code isn’t good, but because the surrounding friction is too high:

How do I structure the project?
How do I set up CI/CD, tests, and linting?
How do I make it look legit?
How do I talk about it?

greening answers all of that in one opinionated workflow.

🌿 Key features

greening automates your project creation pipeline:

✅ greening init…

View on GitHub

Open Source is Soil: The Greening Philosophy

Chris Greening — Mon, 07 Apr 2025 16:00:00 +0000

Open source is soil. It’s not just where we build — it’s where things grow.

The name Greening carries meaning on many levels.

Yes, it's my last name — but more importantly, it reflects the philosophy behind the project and the process it encourages. Greening is an action. A transformation. The turning of raw space into fertile ground.

This project is an attempt to bottle what has worked for me: an opinionated framework, tuned through experience, designed to help ideas take root with clarity and speed.

Chris Greening - Software Developer

Hey! My name's Chris Greening and I'm a software developer from the New York metro area with a diverse range of engineering experience - beam me a message and let's build something great!

christophergreening.com

🌱 Growth Through Iteration

In nature, growth is uneven. Shoots twist toward the light. Some seeds don’t sprout. But the garden keeps expanding. The same is true in software. Version 0.1.0 isn’t perfect — but it’s alive.

Greening exists to make that early stage effortless — to remove friction from the planting process so developers can ship sooner and iterate faster. The first version doesn’t have to be flawless. It just has to start growing.

🌰 Tools Are Seeds

Every scaffold, every config, every deploy is a seed — small, but full of potential. Greening gives you tools that sprout quickly, so you can spend less time building the planter and more time tending the plant.

With expressive syntax and beautiful defaults, it clears the weeds so your work can flourish.

greening new
greening deploy

🌿 Open Source Is Soil

The open-source ecosystem is a living commons. Code evolves. Ideas hybridize. Communities self-seed. In this shared soil, a single contribution can propagate far beyond its roots.

Greening is built for that environment. It’s not just an automation tool — it’s a substrate for creative, scalable, repeatable growth. Tweak it. Fork it. Grow your own extensions. Contribute back.

🌾 Greening, Together

This project is opinionated — not because there’s one way to build, but because strong soil grows strong roots. Greening reflects one approach that’s worked — and makes it easy to remix for your own.

If you're here, you’re already in the garden. Let’s see what we can grow.

Follow the project on GitHub:
👉

chris-greening / greening

greening is an opinionated, lightweight project automation tool for solo developers and creative coders. With just a few commands, you can scaffold a production-ready Python package — complete with docs, tests, GitHub Actions workflows, PyPI packaging, and an auto-deployed GitHub Pages site. No boilerplate. No setup hell. Just instant polish.

🌱 Greening

greening is an opinionated, full-stack Project as Code automation tool for solo developers and creative coders.

🍃 Why `greening`?

Most devs never ship their tools. Not because the code isn’t good, but because the surrounding friction is too high:

How do I structure the project?
How do I set up CI/CD, tests, and linting?
How do I make it look legit?
How do I talk about it?

greening answers all of that in one opinionated workflow.

🌿 Key features

greening automates your project creation pipeline:

✅ greening init…

View on GitHub

Greening is looking for beginner open source contributors!

Chris Greening — Sun, 06 Apr 2025 18:56:56 +0000

Hello!

I'm the creator of Greening, a lightweight CLI that automates launching new open source projects. It handles everything from scaffolding your folder structure to setting up a GitHub repo and deploying a GitHub Pages site all from a single greening.yaml config.

🌱 TL;DR: It's a dev automation tool designed to help you ship beautiful software fast.

🧩 What is Greening?

Greening is for folks who build lots of small tools, libraries, or creative experiments and want to avoid the tedious boilerplate every time. It's especially useful for beginners, solo devs, makers, and people who love polished projects but hate setup tasks.

Here's what it can do:

greening init    # create greening.yaml with intelligent defaults
greening new     # scaffold your project, venv, and GitHub repo
greening deploy  # auto-generate a GitHub Pages site

chris-greening / greening

greening is an opinionated, lightweight project automation tool for solo developers and creative coders. With just a few commands, you can scaffold a production-ready Python package — complete with docs, tests, GitHub Actions workflows, PyPI packaging, and an auto-deployed GitHub Pages site. No boilerplate. No setup hell. Just instant polish.

🌱 Greening

greening is an opinionated, full-stack Project as Code automation tool for solo developers and creative coders.

🍃 Why `greening`?

Most devs never ship their tools. Not because the code isn’t good, but because the surrounding friction is too high:

How do I structure the project?
How do I set up CI/CD, tests, and linting?
How do I make it look legit?
How do I talk about it?

greening answers all of that in one opinionated workflow.

🌿 Key features

greening automates your project creation pipeline:

✅ greening init…

View on GitHub

🌿 I'm Looking for Beginner-Friendly Contributors!

Whether you're new to open source or just looking for a welcoming project to contribute to, I’d love to have you on board.

There are:

🟢 Labeled issues for first-time contributors
📦 Opportunities to improve CLI help output, flags, and structure
🧪 Testing-related tasks (unit tests, GitHub Actions)
🌍 Docs, blog posts, and site improvements

You don’t need to be a senior dev. If you:

Know a bit of Python
Are curious about open source
Want to build something real that helps other developers

You’re in the right place.

🔗 How to Get Started

Head to the issues tab and look for good first issue
Drop a comment and say hi! Or open a discussion if you want to pitch ideas
Feel free to fork + start exploring

If you need help setting up your environment or getting comfortable with the code, I’m happy to walk through it with you!

🙌 Why Contribute?

You'll learn how to structure CLI tools, package Python projects, and automate real dev workflows.
You'll get real GitHub contribution experience.
You'll see your name in the README and commits of a growing tool and community

Plus, the tool you help build will help other devs build faster and better.

💬 Drop a comment below if you’re interested, or jump into the GitHub issues and claim one!

Let’s build something cool together 🌱

Chris Greening - Software Developer

Hey! My name's Chris Greening and I'm a software developer from the New York metro area with a diverse range of engineering experience - beam me a message and let's build something great!

christophergreening.com

The Philosophy Behind Greening: Developer Momentum

Chris Greening — Sat, 05 Apr 2025 16:00:00 +0000

"The best time to build is when you're most excited — so why does setup always get in the way?"

When I started building Greening, it wasn’t just to automate project scaffolding. It was to protect something much more fragile: momentum.

Chris Greening - Software Developer

Hey! My name's Chris Greening and I'm a software developer from the New York metro area with a diverse range of engineering experience - beam me a message and let's build something great!

christophergreening.com

⚙️ The Hidden Cost of Boilerplate

Every time I start a new project, I hit the same wall:

Creating a README
Spinning up a virtual environment
Configuring GitHub Actions
Deploying to GitHub Pages
Setting up analytics, docs, versioning...

None of this is hard — but it's all friction. And that friction adds up right at the moment you're most energized and ready to create.

By the time everything's wired together, the excitement fades, and the magic of that initial idea gets buried under boilerplate.

🌱 Greening Is Built for Momentum

Greening is my attempt to codify that initial burst of energy — and make sure nothing slows it down.

With a single command like:

greening new

You're not just scaffolding a folder. You're generating:

A working GitHub project
A committed Git repo (optionally pushed)
GitHub Actions wired up
A PyPI-ready Python package
Documentation deployed to GitHub Pages
Optional Google Analytics tracking

No decisions to make. No boilerplate to copy. You can go from idea → working, publishable project in seconds.

🛠 Tools Are Philosophy

I’ve come to believe that developer tools encode values.

Greening encodes a belief that:

Starting should be fast
Publishing should be default
Projects should look polished right out of the gate
Repetition should be automated

Because the sooner we can remove friction, the sooner we can get to the good stuff — the real creative work.

🚀 What’s Next?

Greening is still early, but it’s growing fast. I’m working on:

Plugin support for different stacks
Automatic changelog generation
Custom templates for repeatable custom GitHub Pages deployments

If you're someone who wants to spend less time setting up and more time shipping, I’d love your feedback.

Follow the project on GitHub!:

chris-greening / greening

greening is an opinionated, lightweight project automation tool for solo developers and creative coders. With just a few commands, you can scaffold a production-ready Python package — complete with docs, tests, GitHub Actions workflows, PyPI packaging, and an auto-deployed GitHub Pages site. No boilerplate. No setup hell. Just instant polish.

🌱 Greening

greening is an opinionated, full-stack Project as Code automation tool for solo developers and creative coders.

🍃 Why `greening`?

Most devs never ship their tools. Not because the code isn’t good, but because the surrounding friction is too high:

How do I structure the project?
How do I set up CI/CD, tests, and linting?
How do I make it look legit?
How do I talk about it?

greening answers all of that in one opinionated workflow.

🌿 Key features

greening automates your project creation pipeline:

✅ greening init…

View on GitHub

Let's spend less time on boilerplate and more time building.

That’s the heart of Greening.

How to Enable Google Analytics Tracking in Your Greening-Deployed Site

Chris Greening — Sat, 05 Apr 2025 02:05:32 +0000

Want to track visitors to your open-source project site or personal portfolio? Greening makes it easy to wire up Google Analytics — no manual editing required.

Chris Greening - Software Developer

Hey! My name's Chris Greening and I'm a software developer from the New York metro area with a diverse range of engineering experience - beam me a message and let's build something great!

christophergreening.com

With just a few lines in your greening.yaml config, you can automatically include a Google Analytics tracking ID in your deployed GitHub Pages site.

🧠 Why This Is Useful

Traditional static site setups (Jekyll, Hugo, etc.) require you to:

Manually edit template files or _config.yml
Copy and paste Google scripts
Hope nothing breaks in the build

Greening skips all that. Just provide your tracking tag, and it handles the rest.

📈 What You’ll Need

A Google Analytics 4 property
The Measurement ID (e.g., G-XXXXXXXXXX)
A Greening project with a configured greening.yaml

✏️ Step 1: Grab Your Tracking Tag

Go to Google Analytics
Select or create a GA4 property
Navigate to Admin → Data Streams → Web
Copy the Measurement ID (starts with G-)

📄 Step 2: Paste It into `greening.yaml`

In your project’s root directory, open or create a greening.yaml file and add:

google_analytics: G-XXXXXXXXXX

Replace G-XXXXXXXXXX with your actual tag.

🚀 Step 3: Deploy Your Site

Run the following command to generate and publish your GitHub Pages site:

greening deploy

Greening will:

Render your site using Jekyll and the Minimal Mistakes theme
Inject your analytics tag automatically
Push it to the gh-pages branch

✅ You’re Done!

Visit your site, and you’ll start seeing traffic data appear in your GA4 dashboard — no manual setup, no scripts to mess with.

Greening’s mission is to make launching, documenting, and deploying projects fast, beautiful, and automated. Adding analytics should never be the bottleneck.

You can follow the project or contribute on GitHub:
👉 https://github.com/chris-greening/greening

chris-greening / greening

greening is an opinionated, lightweight project automation tool for solo developers and creative coders. With just a few commands, you can scaffold a production-ready Python package — complete with docs, tests, GitHub Actions workflows, PyPI packaging, and an auto-deployed GitHub Pages site. No boilerplate. No setup hell. Just instant polish.

🌱 Greening

greening is an opinionated, full-stack Project as Code automation tool for solo developers and creative coders.

🍃 Why `greening`?

Most devs never ship their tools. Not because the code isn’t good, but because the surrounding friction is too high:

How do I structure the project?
How do I set up CI/CD, tests, and linting?
How do I make it look legit?
How do I talk about it?

greening answers all of that in one opinionated workflow.

🌿 Key features

greening automates your project creation pipeline:

✅ greening init…

View on GitHub

Introducing Greening: Ship Beautiful Software, Fast

Chris Greening — Fri, 04 Apr 2025 15:00:00 +0000

I built Greening because I was tired of boilerplating the same setup over and over again. GitHub Actions, README templates, virtualenvs, docs, deployment pipelines — it adds up fast. And even worse, it slows you down right at the moment you're most excited to build something new.

Chris Greening - Software Developer

Hey! My name's Chris Greening and I'm a software developer from the New York metro area with a diverse range of engineering experience - beam me a message and let's build something great!

christophergreening.com

Greening is an open source automation tool that eliminates the friction of starting, documenting, and shipping your next software project. Whether it's a Python package, a portfolio project, or a polished GitHub Pages site, Greening handles the scaffolding, Git setup, documentation, and even optional Google Analytics integration — all in one command.

Why I Built It

As a solo dev, context-switching kills momentum. I found myself avoiding small projects simply because I didn't want to spend an hour setting up the boilerplate. So I asked:

What if I could automate the launch of my projects just like I automate my tests, builds, and deployments?

Greening grew from that idea.

What It Does

📁 greening new creates a new project, scaffolds a clean structure, and optionally sets up Git, virtual environments, and GitHub remotes.
🌐 greening deploy generates and deploys a beautiful Jekyll-based GitHub Pages site — perfect for project documentation.
📊 Google Analytics integration? Just drop your tag into the config, and you're done.
⚙️ Customizable YAML-based config with opinionated defaults that get out of your way.

Philosophy

Greening is built on a few key ideas:

Ship fast. Don’t let tooling slow down your ideas.
Repeatable and scalable. Make every project look clean and polished from day one.
Beautiful by default. Your software deserves a good first impression.
Automation-first. If you’ve done it more than twice, Greening should probably do it for you.

What’s Next

I’m working toward a plugin-based ecosystem so you can extend Greening to match your exact workflow. Want to auto-generate CHANGELOGs? Autodoc your Python code? Auto-post releases to social media? That’s where we’re headed.

You can check out the project on GitHub here 👉

chris-greening / greening

greening is an opinionated, lightweight project automation tool for solo developers and creative coders. With just a few commands, you can scaffold a production-ready Python package — complete with docs, tests, GitHub Actions workflows, PyPI packaging, and an auto-deployed GitHub Pages site. No boilerplate. No setup hell. Just instant polish.

🌱 Greening

greening is an opinionated, full-stack Project as Code automation tool for solo developers and creative coders.

🍃 Why `greening`?

Most devs never ship their tools. Not because the code isn’t good, but because the surrounding friction is too high:

How do I structure the project?
How do I set up CI/CD, tests, and linting?
How do I make it look legit?
How do I talk about it?

greening answers all of that in one opinionated workflow.

🌿 Key features

greening automates your project creation pipeline:

✅ greening init…

View on GitHub

Simulating simple CRT and glitch effects in Pygame

Chris Greening — Sun, 23 Mar 2025 17:13:39 +0000

For my retro-style arcade shooter Planetoids, I wanted to give the visuals a nostalgic kick—like you were staring at a dusty CRT screen in an '80s arcade.

I also wanted VHS-style glitch effects that make the screen feel alive—shaking, flickering, distorting—especially when something chaotic is happening in-game.

In this post, I’ll walk through how I implemented all of that using plain Pygame.

🔧 Overview: `apply_crt_effect`

Here's the single entry point we use every frame:

apply_crt_effect(screen, intensity="medium", pixelation="minimum")

This applies multiple visual layers that can be configured through the settings screen:

Scanlines
Pixelation
Flicker
Glow
VHS-style glitch effects (jitter, static, color separation)

Let’s break each one down.

1. `Scanlines`: Simulating CRT Lines

def _apply_scanlines(screen):
    width, height = screen.get_size()
    scanline_surface = pygame.Surface((width, height), pygame.SRCALPHA)

    for y in range(0, height, 4):
        pygame.draw.line(scanline_surface, (0, 0, 0, 60), (0, y), (width, y))

    screen.blit(scanline_surface, (0, 0))

This draws semi-transparent horizontal black lines across the screen, spaced every 4 pixels, simulating the horizontal scanlines seen on CRT monitors.

Want more intense lines? Decrease the spacing or increase alpha.
It adds an immediate analog vibe and subtly breaks up the digital sharpness.

2. `Pixelation`: Deliberate Resolution Downgrade

def _apply_pixelation(screen, pixelation):
    pixelation = {"minimum": 2, "medium": 4, "maximum": 6}.get(pixelation, 2)
    width, height = screen.get_size()
    small_surf = pygame.transform.scale(screen, (width // pixelation, height // pixelation))
    screen.blit(pygame.transform.scale(small_surf, (width, height)), (0, 0))

This temporarily shrinks the screen resolution and scales it back up, creating a pixelated, low-res effect.

We use this after rendering everything else so the whole frame gets affected.
Makes the game feel more gritty and less digital-clean.

3. `Flicker`: A Soft Glow Pulse

def _apply_flicker(screen):
    if random.randint(0, 20) == 0:
        flicker_surface = pygame.Surface(screen.get_size(), pygame.SRCALPHA)
        flicker_surface.fill((255, 255, 255, 5))
        screen.blit(flicker_surface, (0, 0))

Every so often (about 5% of frames), a subtle white overlay is applied.

This simulates the fluctuating brightness of a CRT bulb.
Super subtle, but it makes the screen feel alive, especially when combined with glow.

4. `Glow`: Simulated Light Bleed

def _apply_glow(screen):
    width, height = screen.get_size()
    glow_surf = pygame.transform.smoothscale(screen, (width // 2, height // 2))
    glow_surf = pygame.transform.smoothscale(glow_surf, (width, height))
    glow_surf.set_alpha(100)
    screen.blit(glow_surf, (0, 0))

This creates a soft bloom/glow effect by:

Downscaling the screen (blurring it),
Upscaling it again,
Layering it back on top.

It's an easy way to fake blur and create that soft glow old CRTs had when they burned too bright.

5. `VHS Glitch`: The Controlled Chaos

This section ties everything together by adding movement, noise, and distortion.

5.1 Horizontal Slice Glitches

def _add_glitch_effect(height, width, glitch_surface, intensity):
    shift_amount = {"minimum": 10, "medium": 20, "maximum": 40}.get(intensity, 20)
    if random.random() < 0.1:
        y_start = random.randint(0, height - 20)
        slice_height = random.randint(5, 20)
        offset = random.randint(-shift_amount, shift_amount)

        slice_area = pygame.Rect(0, y_start, width, slice_height)
        slice_copy = glitch_surface.subsurface(slice_area).copy()
        glitch_surface.blit(slice_copy, (offset, y_start))

Random slices of the screen are offset left or right—mimicking VHS tracking issues or old screen flickers.

Triggered randomly per frame.
Intensity controls how far the lines can jump.

5.2 RGB Color Separation

def _add_color_separation(screen, glitch_surface, intensity):
    color_shift = {"minimum": 2, "medium": 6, "maximum": 10}.get(intensity, 4)
    if random.random() < 0.05:
        for i in range(3):
            x_offset = random.randint(-color_shift, color_shift)
            y_offset = random.randint(-color_shift, color_shift)
            color_shift_surface = glitch_surface.copy()
            color_shift_surface.fill((0, 0, 0))
            color_shift_surface.blit(glitch_surface, (x_offset, y_offset))
            screen.blit(color_shift_surface, (0, 0), special_flags=pygame.BLEND_ADD)

This simulates the separation of red, green, and blue channels for glitchy VHS color bleed.

Only triggers occasionally.
Intensity controls how far apart the color layers get.

5.3 Rolling Static

def _add_rolling_static(screen, height, width, intensity):
    static_chance = {"minimum": 0.1, "medium": 0.3, "maximum": 0.8}.get(intensity, 0.2)
    static_surface = pygame.Surface((width, height), pygame.SRCALPHA)

    for y in range(0, height, 8):
        if random.random() < static_chance:
            pygame.draw.line(static_surface, (255, 255, 255, random.randint(30, 80)), (0, y), (width, y))

    screen.blit(static_surface, (0, 0), special_flags=pygame.BLEND_ADD)

A final touch: horizontal white noise lines that appear and disappear in random rows.

Like old static interference rolling up the screen.
Controlled by intensity, which raises or lowers the frequency.

🧠 Final Thoughts

All of this runs in real time using Pygame’s surface tools.

None of it requires shaders, OpenGL, or special GPU code and is a fairly lightweight approach for integrating into 2D games.

These effects make Planetoids feel like an experience—not just a game. When the screen distorts after a power-up or flickers from a near-death explosion, you don’t just see it you feel it.

🚀 Try It Out

You can install Planetoids via pip:

pip install planetoids-game

then start right from the command line

> planetoids

chris-greening / planetoids

Planetoids is a fast-paced, retro-inspired arcade space shooter built in Python with Pygame. Dodge asteroids and experience a vintage arcade feel with CRT effects, glitch animations, and pixel-perfect scaling.

Planetoids: A Retro-Inspired Space Shooter

What is it?

Planetoids is a fast-paced, retro-inspired arcade space shooter built in Python with Pygame.
Dodge asteroids and experience a vintage arcade feel with CRT effects, glitch animations, and pixel-perfect scaling.

🪐 Key Features

Fast-paced asteroid destruction
Smooth FPS-independent physics
Retro CRT visual effects & glitch animations
Classic arcade gameplay mechanics
Power-ups and increasing difficulty
Pixel-perfect scaling for all screen sizes

💾 Installation

🔹 Install from PyPI (Recommended)

The easiest way to install Planetoids is through pip:

pip install planetoids-game

Once installed, launch the game by running:

planetoids

🔹 Install from Source

If you want the latest development version, you can install directly from GitHub:

git clone https://github.com/chris-greening/planetoids-game.git
cd planetoids-game
pip install -e .

Then, start the game with:

planetoids

🚀 Running the Game

Once installed, you can start Planetoids in one of the following ways:

🔹 Run from Source

If…

View on GitHub

Follow along for more devlogs, insights, and behind-the-scenes experiments.

Conclusion

Thanks so much for reading and if you liked my content, be sure to check out some of my other work or connect with me on social media or my personal website 😄

Chris Greening - Software Developer

Hey! My name's Chris Greening and I'm a software developer from the New York metro area with a diverse range of engineering experience - beam me a message and let's build something great!

christophergreening.com

Cheers!

Draw beautiful geometric visualizations with Python and Spyrograph

Chris Greening ・ Mar 12 '23

#python #math #opensource #showdev

I added a JavaScript arcade game to my portfolio's homepage

Chris Greening ・ Jun 8 '21

#showdev #javascript #webdev #blogging

Planetoids! - my first attempt at indie game dev in Python

Chris Greening — Thu, 20 Mar 2025 12:30:00 +0000

A couple of weeks ago, I visited a retro arcade packed with classic cabinets from the ‘70s and ‘80s—Space Invaders, Centipede, Joust, you name it. Growing up, one of my favorite memories was playing Galaga every Friday at a diner while visiting my grandparents, so I’ve always had a soft spot for old arcade games.

After that arcade trip, I left with a thought:

"I should try making one of these myself."

I’d been meaning to learn Pygame for years, so this felt like the perfect excuse. At first, I considered tackling one of my absolute favorites Defender, but after realizing how complex the scrolling mechanics were for my first attempt, I pivoted to something simpler—(yet another 😅) Asteroids clone.

A couple dozen hours later, I’ve got Planetoids—a fast-paced, glitchy, take on the classic. It’s a full-on retro space shooter with juicy explosions, ricocheting lasers, power-ups, and plenty of chaotic moments.

If you want to check it out, it’s up on PyPI (pip install planetoids-game) and available on GitHub.

Thanks so much for reading and if you liked my content, be sure to check out some of my other work or connect with me on social media or my personal website 😄

Chris Greening - Software Developer

Hey! My name's Chris Greening and I'm a software developer from the New York metro area with a diverse range of engineering experience - beam me a message and let's build something great!

christophergreening.com

Cheers!

Draw beautiful geometric visualizations with Python and Spyrograph

Chris Greening ・ Mar 12 '23

#python #math #opensource #showdev

I added a JavaScript arcade game to my portfolio's homepage

Chris Greening ・ Jun 8 '21

#showdev #javascript #webdev #blogging

Calculating weighted averages with numpy and Python!

Chris Greening — Tue, 22 Aug 2023 13:00:00 +0000

Introduction

Navigating the world of data often means operating in scenarios where not all data points have the same importance as one another

This is where the weighted average, a statistical tool that assigns importance to each value, helps us incorporate the context of a situation into our average calculations!

import numpy as np

With Python's versatile ecosystem we're able to leverage tools such as numpy to quickly and efficiently calculate the weighted average in our analyses and data projects

Prerequisites and installation
What is the weighted average?
Examining a simple example
Using np.average to calculate weighted mean
Conclusion
Additional resources

Chris Greening - Software Developer

Hey! My name's Chris Greening and I'm a software developer from the New York metro area with a diverse range of engineering experience - beam me a message and let's build something great!

christophergreening.com

Prerequisites and installation

The following package is a prerequisite installation for following along with this blog post!

numpy

To install it open your preferred terminal/console and run:

pip3 install numpy

What is the weighted average?

The weighted average is an extension of a typical arithmetic mean that includes the importance (or weight) of each data point when calculating the average

In scenarios where all data points have the same importance, the weighted average simplifies to the standard arithmetic mean. However, when the significance of each data point varies the weighted average becomes a vital tool

Examining a simple example

Let's consider an example where we are a data scientist employed by a university to calculate the average student grade across all classes in the school

To preserve the privacy of individual students we are only provided data aggregated at the class level and are thus given each individual class'

average grade
number of students

Our initial instinct might be to just take the usual average across all classes but what happens when comparing small classes to very large classes?

If a class has an average test score of 20/100 but only has 4 students is it fair to compare it to a class that has an average test score of 93 and 500 students? No!

If we did that the small class would be given an outsized level of importance as the test grades of just 4 students should not impact the overall mean as much as 500 students

So how do we incorporate the number of students into our university grade average?

With the weighted average!

Using np.average to calculate weighted average

Continuing with the previous example let's say these are the grades and their respective number_of_students per class:

grades = [20, 93, 56, 79, 100, 86]
number_of_students = [4, 500, 93, 274, 12, 30]

To get the weighted average across the entire university using numpy all we have to do is incorporate the weights into the np.average:

import numpy as np
university_average = np.average(grades, weights=number_of_students)
print(university_average)

>>> 84.57174151150055

Conclusion

And just like that we're able to quickly incorporate the weighted average into our projects by leveraging the np.average's weights argument

Thanks so much for reading and if you liked my content, be sure to check out some of my other work or connect with me on social media or my personal website 😄

Chris Greening - Software Developer

Hey! My name's Chris Greening and I'm a software developer from the New York metro area with a diverse range of engineering experience - beam me a message and let's build something great!

christophergreening.com

Cheers!

Effortlessly scrape HTML tables into Python using pd.read_html!

Chris Greening ・ Aug 8 '23

#python #datascience #webscraping #tutorial

Completing missing combinations of categories in our data with pandas.MultiIndex!

Chris Greening ・ Feb 4 '23

#python #datascience #tutorial #pandas

Forem: Chris Greening

Documentation That Builds Itself with Sphinx + Read the Docs

🌿 Docs with Zero Effort

🚀 Instant Hosting with Read the Docs

Summary

GitHub Autodetection Comes to Greening

How It Works

Why We Did This

What’s Next

🌱 New Feature: Beautiful Per-Command Help for the Greening CLI

🌱 How It Works

🌾 Why This Matters

🌱 What’s Next?

How to Generate a GitHub Token for Pushing Repos with Greening

🔐 Step 1: Generate a New Token

🧠 Step 2: Add It to Your Environment

Unix/macOS

Windows (Command Prompt)

Windows (PowerShell)

✅ Step 3: Use It with Greening

🧼 Bonus: Keeping Your Token Safe

chris-greening / greening

🌱 Greening

Table of Contents

🍃 Why greening?

🌿 Key features

Open Source is Soil: The Greening Philosophy

🌱 Growth Through Iteration

🌰 Tools Are Seeds

🌿 Open Source Is Soil

🌾 Greening, Together

chris-greening / greening

🌱 Greening

Table of Contents

🍃 Why greening?

🌿 Key features

Greening is looking for beginner open source contributors!

🧩 What is Greening?

chris-greening / greening

🌱 Greening

Table of Contents

🍃 Why greening?

🌿 Key features

🌿 I'm Looking for Beginner-Friendly Contributors!

🔗 How to Get Started

🙌 Why Contribute?

The Philosophy Behind Greening: Developer Momentum

⚙️ The Hidden Cost of Boilerplate

🌱 Greening Is Built for Momentum

🛠 Tools Are Philosophy

🚀 What’s Next?

chris-greening / greening

🌱 Greening

Table of Contents

🍃 Why greening?

🌿 Key features

How to Enable Google Analytics Tracking in Your Greening-Deployed Site

🧠 Why This Is Useful

📈 What You’ll Need

✏️ Step 1: Grab Your Tracking Tag

📄 Step 2: Paste It into greening.yaml

🚀 Step 3: Deploy Your Site

✅ You’re Done!

chris-greening / greening

🌱 Greening

Table of Contents

🍃 Why greening?

🌿 Key features

Introducing Greening: Ship Beautiful Software, Fast

Why I Built It

What It Does

Philosophy

What’s Next

chris-greening / greening

🌱 Greening

Table of Contents

🍃 Why greening?

🌿 Key features

Simulating simple CRT and glitch effects in Pygame

🔧 Overview: apply_crt_effect

🍃 Why `greening`?

🍃 Why `greening`?

🍃 Why `greening`?

🍃 Why `greening`?

📄 Step 2: Paste It into `greening.yaml`

🍃 Why `greening`?

🍃 Why `greening`?

🔧 Overview: `apply_crt_effect`

1. `Scanlines`: Simulating CRT Lines

2. `Pixelation`: Deliberate Resolution Downgrade

3. `Flicker`: A Soft Glow Pulse

4. `Glow`: Simulated Light Bleed

5. `VHS Glitch`: The Controlled Chaos