That post still works, and the script still runs. But it taught the wrong objective for half the contests people play. And it assumed the person running it was you, pasting code into a Live Script. Both of those changed, so I rebuilt the thing.

The repo is the same one: github.com/nothans/dfs-optimizer. It now has a function library, an app for exploring the options, a test suite, and a section for coding agents. In 2026 the “user” of a tool like this is as likely to be Claude Code or OpenAI Codex with a MATLAB session open as it is to be a human with a mouse. This post is the new tutorial.

What the 2022 script got right, and what it got wrong

The 2022 model was one binary variable per player and a handful of linear constraints: one QB, one defense, two to three running backs, three to four receivers, one to two tight ends, nine players total, salary under the cap. Maximize projected points. That is still the core, and the new code returns the identical lineup on the same data. There is a test that proves it.

What it got wrong is subtler. “Maximize projected points” is the correct objective for a cash game, a 50/50 or a double-up, where you’re paid if you finish in the top half. You want the highest floor, and the highest projection is a decent proxy.

It’s the wrong objective for a tournament (a GPP, guaranteed prize pool), where a few thousand entries compete for a top-heavy payout and the winner needs a top-1% finish. In a tournament, the highest-projected lineup is the lineup everyone else has too. You want ceiling and you want to be different. That means correlated players (a QB and his receiver score on the same plays), lower-owned players (so a hit separates you from the field), and more than one lineup.

Get the data

The projections still come from Daily Fantasy Fuel. Pick the DraftKings or FanDuel tab, clear any filters, let the whole table load, then click Download CSV and save the file. The button exports the rows on screen, so a filtered view gives you a filtered file. The header looks like this:

first_name, last_name, position, injury_status, week, game_date, slate, team, opp,
spread, over_under, implied_team_score, salary, L5_dvp_rank, L5_fppg_avg,
L10_fppg_avg, szn_fppg_avg, ppg_projection, value_projection, ownership_projection

That last column matters. Projected ownership is what makes the tournament levers work, and the 2022 post ignored it.

You don’t need to import the file by hand anymore. The loader reads it directly, drops anyone marked out, and keeps every original column:

players = dfs.loadProjections("DFF_NFL_cheatsheet.csv");

If you don’t have a download handy, the repo ships a synthetic 13-game slate in the same header, with made-up names, so every example below runs as-is, and you’ll meet a few of those names again before this is over.

The app, in five clicks

Open MATLAB in the repo folder (or click the Open in MATLAB Online badge on the README) and run:

DFSOptimizerApp

It opens on the sample slate. Levers on the left, results on the right.

Click one: the Cash game preset, then Optimize. This is the 2022 script with a face. One lineup, maximum projection, no stacking, ownership ignored. On the sample slate it lands at 176.4 projected points and a summed ownership of 192%, which is a polite way of saying “everyone has these players.”

Click two: the Tournament preset, then Optimize. Now the sidebar asks for a QB stack (one receiver or tight end from the QB’s own team), a bring-back (one skill player from the opponent), and no defense against your own QB. It also wants a small penalty on projected ownership and twenty lineups, where nobody appears in more than half and every pair differs by at least three players. A progress bar counts them off, about a quarter second each.

Click any row to see the roster. The summed ownership drops into the 70 to 150 range and the QB column shows the portfolio spreading across three or four quarterbacks instead of one.

Click three: lock and exclude. The Player pool tab is the whole slate with two checkbox columns. Tick Lock on a player you believe in and Exclude on one you don’t, and every solve from then on honors it.

Click four: Exposure. This is the chart I wanted in 2022 and didn’t have. Your exposure per player across the twenty lineups, next to the field’s projected ownership. The gap is leverage. A player you have at 40% who the field has at 2% is where a tournament gets won or lost.

Click five: Simulate. A projection is a mean, not a promise. The Monte Carlo tab draws fifty (or five hundred) noisy versions of the projections, re-solves the lineup for each one, and counts who made it. A player who’s optimal in 60% of the draws is a play. A player who’s optimal only at the exact point estimate is a coin flip with a good agent.

There’s a sixth button, Copy as code, and it’s the one I use most. It writes your current sidebar as a function call and puts it on the clipboard, so a session in the app turns into a script you can rerun next week:

players = dfs.loadProjections("data/sample_DFF_NFL.csv");
[lineups, summary, exposure] = dfs.generateLineups(players, 20, ...
    Site="DraftKings", SalaryCap=50000, OwnershipWeight=0.05, StackSize=1, BringBack=1, ...
    AvoidQBvsDST=true, MaxExposure=0.5, MinUnique=3, Randomness=0.1, Seed=1);

The levers, one constraint each

The app is a thin layer over a package called +dfs, and every lever is a name-value option on dfs.optimizeLineup. Each one is a single linear constraint on the same binary variables the 2022 script used. Plain words first, then the code, lever by lever.

Stack. For every quarterback in the pool, “the number of his own receivers and tight ends you pick is at least k times whether you picked him.” When you don’t pick him the right side is zero and the constraint sleeps. When you do, it demands k partners. No big-M tricks, one row per QB.

L = dfs.optimizeLineup(players, StackSize=2);

Bring-back. The same shape, aimed at the opponent’s skill players. It bets on a shootout.

L = dfs.optimizeLineup(players, StackSize=1, BringBack=1);

No QB against your own defense. A pairwise exclusion: QB plus the opposing defense is at most one. Your defense scores when his offense fails. Do not root against yourself.

L = dfs.optimizeLineup(players, AvoidQBvsDST=true);

Ownership penalty. Instead of maximizing projection, maximize projection minus lambda times projected ownership. On the sample slate, a lambda of 0.05 with a two-man game stack gives up 3.8 points and sheds 23 points of summed ownership.

[L, info] = dfs.optimizeLineup(players, OwnershipWeight=0.05);

Exposure and uniqueness. When you build twenty lineups in a row, each new solve gets two extra rules: players at their exposure cap sit out, and “the overlap with every earlier lineup is at most nine minus u players.”

[lineups, summary, exposure] = dfs.generateLineups(players, 20, MaxExposure=0.4, MinUnique=3);

FanDuel. Different cap, a four-per-team limit, three-team minimum. One word.

L = dfs.optimizeLineup(players, Site="FanDuel");

If you like your math in one block, this is the whole model:

maximize    sum_i (p_i - lambda * o_i) x_i
subject to  sum_i x_i = 9
            1 QB, 1 DST, 2-3 RB, 3-4 WR, 1-2 TE
            sum_i s_i x_i <= cap
            players from at least 2 games            (DraftKings)
            at most 4 per team, at least 3 teams     (FanDuel)
            partners of QB q  >= k * x_q             (stack)
            opponents of QB q >= b * x_q             (bring-back)
            x_q + DST facing q <= 1                  (no QB vs DST)
            overlap with earlier lineup <= 9 - u     (uniqueness)
            x_i in {0, 1}

The FLEX spot isn’t a variable. It’s the slack between each position’s base count and its maximum, pinned by the total of nine. That trick was in the 2022 script and it’s still the reason the model stays at one variable per player.

The academic version, stacking constraints included, is Hunter, Vielma and Zaman’s “Picking Winners in Daily Fantasy Sports Using Integer Programming” from MIT. The levers above are the practical subset every serious optimizer ends up with.

Trust, then verify

Two things happen after every solve, and both are new.

First, the code checks the solver’s exit flag and refuses to hand you a lineup the solver didn’t actually finish. Second, the lineup goes through dfs.validateLineup, a function that knows nothing about the solver. It counts positions, adds salary, checks the games and teams, and complains in plain English if anything is off. If the solver and the validator ever disagree, you get an error, not a lineup.

There are 22 tests. The one I care about most feeds the same slate to the 2022 formulation and the new one and asserts they return the same players and the same 176.4 points. The model got a lot of new rules, but the old answer didn’t move.

The other user: a coding agent

MathWorks ships the MATLAB Agentic Toolkit. It does two things. It installs the MATLAB MCP Server, which gives a coding agent (Claude Code, GitHub Copilot, Codex, Gemini CLI, Amp) a live MATLAB session it can run code in, lint with, and test through. And it installs skills: curated MathWorks knowledge so the agent writes idiomatic MATLAB and stops inventing toolbox functions.

I used two of those skills to build the refresh. matlab-solve-optimization is where “check the exit flag, then validate independently” comes from. matlab-build-app is where the app’s layout comes from (it calls the sidebar-plus-display shape an Explorer, and it’s right). The skills read like design documents from someone who has built a lot of MATLAB apps and solved a lot of optimization problems, which is what they are.

Setting it up takes three steps:

1. Download agenticToolkitInstaller.mltbx, open it in MATLAB, and run setupAgenticToolkit("install"). Pick the skill groups you want; for this repo that’s Math and Optimization, MATLAB App Building, and MATLAB Core. (The installer is shared with the Simulink Agentic Toolkit, which is why the download lives in that repo’s releases.)
2. In MATLAB, run shareMATLABSession() so the agent works in the session you can see.
3. Open the repo in your agent. There’s an AGENTS.md (and a CLAUDE.md for Claude Code) that gives it the map, the rules for changes, and prompts that work.

Then you stop clicking and start asking. This is a real exchange from my session, with the agent driving MATLAB through the MCP server:

Me: Load the sample slate, build 20 DraftKings tournament lineups with a 2-man stack, 40% max exposure and 3 unique players per pair, and tell me the five players where my exposure is furthest above projected ownership.

Agent: Built 20 lineups (164.2 to 173.1 projected points, summed ownership 106% to 187%). Your biggest leverage plays:

Name	Pos	Team	Exposure	Field	Leverage
Nico Ironwood	WR	IND	40%	1.7%	+38.3
Cameron Quillon	WR	DEN	40%	7.5%	+32.5
Gideon Okafor	WR	LAR	40%	7.7%	+32.3
Elliot Ashcombe	TE	MIA	40%	8.7%	+31.3
Xavi Fenwick	WR	NO	40%	11.7%	+28.3

The names are fake because the slate is synthetic. The workflow isn’t. The agent called dfs.generateLineups, sorted the exposure table by leverage, and showed me the top five. Then I asked it to add a rule I had been meaning to write for a year (cap the players from any one game), and it added the constraint, a validator clause, and a test, ran the suite, and reported 23 of 23.

The README’s “getting started” section used to be steps for a person. Now the useful section is a list of prompts, each of which is a claim the agent can check by running the code.

The caveats, because it’s still football

Projections are still projections. The optimizer is only as good as the numbers you feed it, and the numbers are a mean over a game that hasn’t happened.

The Monte Carlo view uses per-position volatility guesses (quarterbacks are steadier than tight ends, defenses are chaos) that I picked, not measured. They’re labeled as working values in the code. Replace them with your own standard deviations if you have them; the simulator will use a StdDev column if it finds one.

The stacking wisdom is what the DFS sites and the MIT paper agree on, but the correlation numbers you see quoted around the internet are site-reported, not something I verified. Treat the levers as structure, not as guarantees.

And the sample slate’s players don’t exist. Please do not roster Nico Ironwood.

Go build one

The code is MIT-licensed at github.com/nothans/dfs-optimizer and on MATLAB File Exchange. The 2022 post is still there if you want to optimize a lineup.

Download a slate, run the Tournament preset, look at the exposure chart, and then argue with it. Let me know what your lineup looked like, and send a pull request if you teach it a new trick.

It did not write a single word back.

That’s Jev, and I think it’s one of the more interesting models to show up this year.

Yes, I made the meme. Jev couldn’t say that line if it tried. You’d have to ask it a yes/no question.

What Jev is

Jev comes from TypeSafe, a San Francisco lab that came out of stealth on September 15. OpenRouter added it three days later as typesafe/jev-1.13, so if you have an OpenRouter key, you already have Jev.

Every frontier lab has spent the last two years teaching models to think longer. TypeSafe went the other way. Jev reads whatever you hand it and answers one of three kinds of question, using only the options you give it.

• Noul: yes or no, as a probability.
• Choice: pick one of up to 255 options you describe.
• Score: place it on a scale you define, “Can wait” to “Blocking revenue right now.”

Every answer comes back with probabilities. No prose to parse, no JSON that’s almost JSON, no invented option. It’s an if-statement that understands English.

It’s also cheap: $0.042 per million input tokens, and output is free. My first call, three questions about one support ticket, came back in 0.6 seconds and cost $0.000017.

Where it fits

Most decisions inside software aren’t essays. They’re “which team gets this ticket,” “is this safe to run,” “is this spam,” “which of these 40 things matters.” We’ve been paying a chatbot to write a paragraph so we could regex one word out of it.

• Routing and triage. Tickets, emails, alerts, pull requests. Pick the queue, score the urgency.
• Gating agents. Before an agent issues a refund or runs a command, ask three yes/no questions. At 0.9 or higher, go. At 0.1 or lower, stop. In between, a human looks. OpenRouter published exactly this recipe.
• Checking an LLM’s homework. Did the answer stick to the source, or make something up? Ship the supported ones, escalate the rest.
• Sorting big piles. Thousands of documents, one question each, ranked by probability.
• Picking instead of writing. Pull the candidate dates or amounts out with a regex, then let Jev choose the right one.

The probabilities are the part I didn’t expect to love. When the model is unsure, it says so, and you fix things by moving a threshold, not rewriting a prompt.

What I built with it

My research repo has 1,140 items in it: voice briefs, news digests, insights, bets, trend signals, blog drafts. I built a thing called Sieve that asks Jev the same question about every one of them and ranks the answers. “Talk-ready.” “Evidence against my community thesis.” “Feeds chapter two of the book.” “A hands-on build that could be demoed live at a developer meetup.” (My CABLE 82 talk came back first, at 95%. Correct.)

Then I checked it against my own filing. I’d already sorted every insight and trend signal into swimlanes by hand, so I stripped the labels and asked Jev to do it. Overall it agreed with me about 8 times in 10. When it said it was confident, 9 times in 10. When it was unsure, it was close to a coin flip, and it told me so.

Sieve is open source

I split Sieve into the engine and my stuff, and put the engine on GitHub: github.com/nothans/sieve. MIT licensed, just Node, no dependencies. Point it at any folder of Markdown, describe what counts as an item and which questions you care about in one config file, and it sifts the whole pile from the command line or a little web UI. My research notes and my config stay on my machine.

It ships with two demos: a made-up research notebook, and all 313 of Aesop’s fables. Ask the fables for “a trick that backfires on the trickster” and it reads every one of them in 1.4 seconds for about a third of a cent.

The Moral preset files every fable under its moral. The Dog and the Shadow came back 100% greed, which seems fair to the dog.

The repo also carries the Jev command-line tool on its own, so any script or agent can grab a typed answer when it needs one.

What tripped me up

Jev reads literally. Really literally. “Projects I could demo live on stage” ranked a Google product launch first, because Jev has no idea who “I” is. “Is this evidence against my thesis” came back as a shrug on everything. Asking for the concrete thing instead (“does this report a community that did fine without human trust?”) fixed it. TypeSafe documents all of this: no math, no counting, no date comparisons, and adversarial text can push it around. It also can’t tell you why, so you get a number and no reason.

The idea is already loose, too. Six open-source clones showed up within about 48 hours, at least one of them running on a single gaming GPU. What got copied is the shape: state in, typed questions in, probabilities out. I think that shape sticks around, whoever ends up serving it.

Creative uses I want to try

• Board game bots. A playtest bot that picks its move from the legal moves, with a persona written in the question.
• A notification bouncer. One yes/no before anything pings my phone: “Is this urgent enough to interrupt someone at dinner?” (Not “would I want this.” Jev doesn’t know who I am.)
• CABLE 82 tonight. Score every headline on “cozy Friday night viewing” and let the 1982 cable channel build its own lineup.
• Moderation with the thresholds in public. Every post gets the same small set of typed judgments, and members can see, and vote on, the numbers that decide what happens.
• A code review tripwire. “Does this diff touch authentication or payments?” before an agent is allowed to merge.
• Alt text that checks itself. Does this description actually say what the chart shows?
• Spreadsheet columns that think. Add a column called “urgency,” type what it means, fill 300 rows in seconds.
• Training its own replacement. Label a big pile of examples with Jev, then train a tiny local model on the labels.

It’s the first AI model I’ve met that’s better at listening than talking.

I know a few people like that. Not many.

Not a set of screws. Not an organized assortment with little labeled drawers. A bin. Machine screws, wood screws, hex nuts, nylon washers, lock washers, standoffs, springs, a couple of red and black binding posts, one rubber foot from something I no longer own, and a half-crushed box of wire nails from the hardware store in the town where I grew up.

Every piece in there came off something. That’s the rule of the bin. Nothing goes in new. It goes in when a project ends, when a gadget dies, when I take something apart to see how it works and it doesn’t go back together the same way (which is most of the time, right).

How It Started

I didn’t decide to start a screw bin. It happened. It started small. You’re cleaning up after a project and there are four leftover screws on the bench and you can’t throw them out because they’re perfectly good screws. So you put them in a cup. Then the cup gets full and you move them to a bag. Then the bag rips, and you buy a bin.

That was decades ago. I know it was decades because that box of wire nails is 25 years old. I bought it at the hardware store where I grew up, and it has been riding along ever since.

The binding posts are from a bench power supply project. The nylon standoffs are from a stack of circuit boards I built during the ioBridge days. Some of the tiny machine screws came out of hard drives that stopped spinning a long time ago. Every layer is a different era. It’s a core sample of my hobbies.

It Has Survived Many Moves

Here’s the part that gets me. That bin has survived several moves. Different houses, different states, a couple of trucks. Every time we packed, there was a moment where someone (usually me) held the bin up and asked the question: do we really need to move a box of random screws across state lines?

And every time, the bin got in the truck.

Not because I had a plan for it. Because throwing it out felt like throwing out a tool. A weird tool that only works one time in fifty.

Now my bag of parallel port cables for my printer and ZIP drives didn’t survive.

The Save

Working on a pinball machine, I needed the perfect screw and bracket. I spent a half hour digging through the bin, partially remembering I had something like what I was thinking. Then, I found it. It was exhilarating.

This has happened more than once. A washer. A bolt for a part I didn’t even know I needed until I needed it. A standoff with the exact thread for a board I was mounting. A nut that fit the one bolt I had left. Every save felt like winning a tiny lottery I had been buying tickets for over decades.

I also never took the time to properly acknowledge the random screw bin. This is my love letter and my attempt to correct the record.

Start Yours

If you build things, start a bin. Today. Any container. Put the leftover screws in it instead of the trash. Don’t sort it, don’t label it, and don’t judge it. A coffee can? Start small… An Altoids box. Just have fun with it.

In ten years, at 9 PM, one screw short, you’ll be glad it exists. And, you can tell your partner, see, I was right to keep this bin!

And when you move, it goes in the truck. And your kids’ kids will be puzzled when they find it. What was grandpa doing with one giant locking washer? Then, they will start one with the gregs of yours, and thank you when they blog using a brain implant. I am certain blogging will survive Web 4.0.

What changed

• Video channels. Drop video files in a folder and point a channel at it. My folder of 90s commercials is now channel 2, for example.
• A broadcast clock. Channels air whether you’re watching or not. Tune away, tune back, and you land mid-program.
• Scheduled hours. Cartoons can keep Saturday-morning hours. Off the air, the channel shows a test card with the resume time, color bars, or static.
• A tuner. Change channels with arrow keys, a USB gamepad, or an HTTP request. Every change cuts through a moment of tuner static and shows a channel banner.
• A demo channel. node channels/fetch-demo-channel.js downloads eight public-domain films from the Internet Archive’s Prelinger collection. Duck and Cover, Design for Dreaming, One Got Fat. A working channel in one command.
• The control room. A Channels panel with a folder picker, a schedule editor, and a week grid of your on-air windows.

The broadcast clock

A normal media player has a play state: what’s playing, where you paused, what’s next. A cable channel has none of that. Its position is a pure function of the wall clock: given the playlist and the time of day, the channel knows exactly what should be on the air and how far into it we are.

That means there is nothing to save and nothing to resume. Tune to channel 2 at 9:14 and you join a commercial already in progress, like TV that doesn’t wait for you.

I changed channels with an Atari joystick

The tuner reads NES-style D-pad buttons and the analog axis, so when I plugged in a single-button Atari USB stick, up and down worked on the first try. A 1977-style controller changing channels on a 1987 television driven by a modern Raspberry Pi. The input doesn’t care what you use: anything that can press a key, close a GPIO pin, or POST to /api/tune is a remote control.

My CABLE 82 network has a channel dedicated to 80s commercials, 90s commercials, retro movies, Beavis and Butthead, music videos, Transformers, Saturday morning cartoons, and the community bulletin board. I have been busy copying old VHS tapes to MP4.

Thermals

Software video decode is the hardest this Pi has ever worked. The bulletin board alone kept the 3 B+ in the high 50s C; continuous video holds it in the low 60s. That trips the 3 B+’s soft temperature cap at 60 C (vcgencmd get_throttled reports 0x80008), which is the chip protecting itself by design – not a power problem, and the picture doesn’t care.

Passive cooling has been fine, but a network that broadcasts around the clock earns a fan. I’m looking at a Raspberry Pi 3 case with a fan and heatsinks. It also comes with a 3A supply with a power switch, but don’t use the power switch. Send a proper shutdown signal to the Raspberry Pi. Older Pi’s can corrupt the SD card.

Get the latest CABLE 82 release

git clone https://github.com/nothans/cable-82
cd cable-82
node server.js

Open the address it prints and you’re on the air with channel 82, the community bulletin board. Run the demo channel fetcher, add it in the control room, and you have a network.

The repo is at github.com/nothans/cable-82. The original build story and the step-by-step tutorial cover the build from a blank SD card to a cable network of your own.

The TV is a Magnavox portable from Facebook Marketplace, a Perfect View from August 1987, the kind with a handle on top, a rod antenna, and a 12V jack so you could watch it in the car.

The Pi is a 3 Model B+, the same board the reader had.

The false start: the original 2012 Pi

My first instinct was to do this on the least capable Pi in the house: the original Model B, board marked “(c)2011.12”, with the 4GB “Debian 6 for Linux” card it came with. Raspberry Pi OS still supports it, which is remarkable for a 2012 computer, and Node.js 20 installs from apt. The server half of CABLE 82 would run fine.

The TV half would not. The original Pi’s chip is ARMv6, and no current browser runs on it. Raspberry Pi dropped Chromium for ARMv6 in 2023; on the current OS it prints “This hardware doesn’t support NEON SIMD extensions” and quits. Firefox is built for ARMv7 and dies the same way. The one engine left is WebKit, with no JavaScript JIT, on a 700MHz core. I looked at that path for a while… and decided the tutorial should be about the channel, not about heroics.

What you need

• Raspberry Pi 3 Model B+ (or any Pi 2 or newer; a Pi 4 is a fine choice too).
• 16GB or larger microSD card. Mine is a SanDisk Ultra PLUS 16GB.
• Micro-USB power supply, 5V at 2.5A. The 3 B+ is the last micro-USB Pi.
• A network connection. Ethernet is simplest for the first boot; the 3 B+ also has Wi-Fi.
• 4:3 CRT with a coax antenna input. Almost every tube TV has one, which is why this is the path that works for everybody. Mine has nothing else: one F connector marked EXT ANT and a switch to pick it over the built-in rod antenna.
• HDMI-to-RF modulator, the little box that turns HDMI into channel 3 or 4 on the antenna input, plus a short coax cable. Mine is an “HDM61” unit; the same design is sold under a dozen brand names.
• Another computer to flash the card and to SSH into the Pi (needs to be on the same network as the Raspberry Pi).

Step 1: Put the OS on the card

Which image, and why

Raspberry Pi OS (64-bit), the desktop edition. It is the image Raspberry Pi’s own kiosk tutorial tells you to use, and there are two practical reasons to follow that advice on a 3 B+:

1. Chromium is the browser that will show the channel, and the 64-bit build is the one that has been solid on Pi 3 boards (the 32-bit build had a will-not-start bug on the Pi 3 as recently as this summer).
2. Node.js 22 from NodeSource is 64-bit only now; their installer refuses 32-bit outright.

The image is a 1.3GB download and takes about 6GB on the card, so 16GB leaves plenty of room.

Flash it with Raspberry Pi Imager

Raspberry Pi Imager is the right tool here, and not balenaEtcher or dd, because it can bake the hostname, your user, and SSH into the card before the Pi ever boots. That is what makes the headless setup work. Install it from raspberrypi.com/software, put the card in your computer, and walk the steps down the left side.

Device: Raspberry Pi 3. This filters the OS list to images that run on the 3 family (A+, B, B+, and Compute Module 3).

OS: Raspberry Pi OS (64-bit). The top entry, marked Recommended. Not the 32-bit one and not the “Legacy” one; Legacy is the older Bookworm release.

Storage: the SD card. Imager hides your system drives by default, so the only thing in the list should be the card. Mine shows up as a 14.8GB “Generic MassStorageClass USB Device” because it is in a USB reader; a 16GB card really is about 14.8GB once you count the way computers count.

Customisation. This is the part Etcher cannot do, and the reason the Pi will come up on the network with no screen attached.

• Hostname: cable82. That gives you cable82.local later, so you never have to go looking for an IP address.
• Localisation: your time zone and keyboard layout. The clock on the channel runs off the Pi’s time zone, so get this right.
• User: a username and password you will remember. You will type them into SSH in a few minutes.
• Wi-Fi: your network name and password. I set it even though the Pi would be on Ethernet for the build; it means the finished TV can live anywhere in the house.
• Remote access: enable SSH, password authentication. I also left Raspberry Pi Connect on, which gives you a browser-based remote shell to the Pi from anywhere, handy for a TV that lives in a corner.

Then Write. Imager asks once more whether it can erase the card, downloads the image, writes it, and verifies it. The write was the slow part: this card takes data at about 10MB/s, so the 6GB image plus verification took about fifteen minutes.

First boot

Imager ejects the card when it is done. Card into the Pi, Ethernet in, power in. The green light flickers for a while: the first boot resizes the filesystem to fill the card, generates SSH keys, and runs a one-time setup pass. Mine answered on the network in well under two minutes. Then from your computer:

ssh yourname@cable82.local

(If .local does not resolve on your machine, your router’s device list will show a cable82 with an IP address; SSH to that instead.)

Three things to check while you are in:

head -2 /etc/os-release
free -m
df -h /

Mine came back Debian 13 (trixie), 905MB of memory with about 570MB available, and a 15GB root partition with 8.4GB free after the 6GB image. The Pi had been up eight minutes by the time I got around to asking. Then bring the image current:

sudo apt update && sudo apt full-upgrade -y

(sudo asks for your password; recent Raspberry Pi OS releases turned off passwordless sudo by default.)

The Pi is on the network, current, and answering SSH.

Step 2: Node.js

CABLE 82 is a Node.js app with no dependencies, so Node is the only thing to install. It needs Node 18 or newer, and a fresh Raspberry Pi OS has none at all:

$ node -v
bash: node: command not found

That line, by the way, is almost certainly what was behind the reader’s “localhost refused to connect.” No Node, no server, nothing listening, and the browser reports it as a refused connection.

Two ways to get Node on a 64-bit Pi. The quick one is the distro’s own package, sudo apt install nodejs, which gives you Node 20. I went with NodeSource for Node 22, the current long-term-support line, and it is two commands:

curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -
sudo apt-get install -y nodejs
node -v

Mine printed v22.23.2. (NodeSource only builds for 64-bit now; if you flashed the 32-bit image, use the apt route.)

Step 3: CABLE 82 on the air

With Node in place, the channel itself is next. Clone it and start it:

cd ~
git clone https://github.com/nothans/cable-82
cd cable-82
node server.js

It prints every address it answers on:

CABLE 82 broadcasting
  http://localhost:1982   (a browser on this machine)
  http://192.168.68.93:1982   (a browser on another device on your network)
Control room: http://localhost:1982/config

Read that second line carefully, because it is the other half of the reader’s problem. localhost means “this machine.” Typed into a browser on your laptop, it asks the laptop for a channel it does not have. The 192.168.x.x address is the Pi as seen from everywhere else on your network, and that is the one to open from the laptop. I did, and the channel was there: blue screen, the clock, the crawl.

The first run also writes a config.json next to the server, which is where everything you change in the control room ends up. Open http://192.168.68.93:1982/config from the laptop and make it yours: channel name, your messages, your feeds, your town for the weather. Save, and the channel picks it up within about twenty seconds.

Make it a service

Ctrl-C the server and hand it to systemd so it runs at boot and restarts if it ever dies. Create /etc/systemd/system/cable82.service:

[Unit]
Description=CABLE 82
After=network-online.target

[Service]
ExecStart=/usr/bin/node /home/cable82/cable-82/server.js
Restart=always
User=cable82

[Install]
WantedBy=multi-user.target

Both cable82s are my username; use yours (whoami tells you, and which node confirms the path on the ExecStart line). Then:

sudo systemctl enable --now cable82
systemctl status cable82

active (running) with the broadcasting lines in its log, and sudo journalctl -u cable82 -f is where to look if anything is ever wrong. The server sits at about 46MB of memory.

Step 4: Chromium in kiosk mode

The desktop image already logs in automatically and starts a Wayland session (the compositor is called labwc; the old LXDE desktop from earlier Pi OS releases is gone). Chromium 151 is preinstalled. All we have to do is tell the session to open Chromium full screen on the channel at login.

The file for that is ~/.config/labwc/autostart. Create it with these lines:

# CABLE 82 kiosk: wait for the channel server, then put Chromium on it full screen.
until curl -s -o /dev/null http://localhost:1982; do sleep 1; done
/usr/bin/lwrespawn /usr/bin/chromium http://localhost:1982   --kiosk --noerrdialogs --disable-infobars --no-first-run --no-memcheck   --disable-lcd-text --autoplay-policy=no-user-gesture-required   --enable-features=OverlayScrollbar --password-store=basic --start-maximized &

A few of those deserve a word:

• The until curl loop waits for the server to answer before launching the browser. Without it, Chromium can win the race at boot and show “localhost refused to connect” on the TV, and nothing ever tells it to try again.
• lwrespawn is a Raspberry Pi helper that restarts a program if it dies, so a crash brings the channel back instead of leaving a blank desktop.
• --no-memcheck stops Chromium from popping a low-memory warning over the channel on a 1GB board.
• --autoplay-policy=no-user-gesture-required lets the background music start without anyone clicking.
• --disable-lcd-text turns off subpixel font smoothing so the chunky text stays crisp white instead of going pink at the edges.
• --password-store=basic keeps the desktop keyring from asking for a password at login.

Then turn off screen blanking, or the TV goes dark after ten minutes:

sudo raspi-config nonint do_blanking 1

(Or interactively: sudo raspi-config > Display Options > Screen Blanking > No.)

If you are here from the original post: the chromium-browser --kiosk line and the /etc/xdg/lxsession/LXDE-pi/autostart file in that post were for the previous Pi OS release. On Trixie the binary is chromium and the file is the labwc one above.

Reboot. About a minute later Chromium was running full screen on the channel. I could tell from the laptop before the TV was even connected:

$ pgrep -a chromium | head -1
1407 /usr/lib/chromium/chromium ... --kiosk ... http://localhost:1982

Check the power supply while you are here

This section wasn’t what I expected. My first run was off a phone charger…

$ vcgencmd get_throttled
throttled=0xd0005
$ vcgencmd measure_clock arm
frequency(48)=600064000

Any bit set in get_throttled is a complaint; 0x5 means under-voltage and throttling right now, and the clock line shows a 1.4GHz Pi running at 600MHz. It worked, in the sense that the channel was on, but at less than half speed. With a proper 5V 2.5A supply the under-voltage bits cleared and the clock came back up. If you only run one check from this whole post on an existing Pi, run that one.

(On a 3 B+ you may still see 0x80008 with a 1.2GHz clock: that is the board’s own soft temperature limit at 60C, normal with Chromium running, and nothing to do with power.)

Step 5: The CRT

Note on photos of the TV… it turns out to be surprisingly hard to get a good photo of the screen. My phone didn’t capture it well. Also, the screen had a giant smudge backed into the acrylic covering the TV. I had to use Novus 2 polish to clean up the smudge and scratches. I assure you that it looks better in person…

The Magnavox has exactly one way in: an F connector marked EXT ANT.

So the path is HDMI out of the Pi into a small HDMI-to-RF modulator, coax from the modulator into the TV, and the TV tuned to channel 3. The box is the size of a cassette tape, takes USB power, has a CH3/CH4 switch, and its spec sheet says everything you need to know: NTSC out, 480p to 1080p in, sound on the 4.5MHz carrier (that means mono, the way 1982 did it).

Plug it all in and the channel was on the tube.

Send it a 4:3 picture

The box scales whatever it gets to fill the 4:3 tube. CABLE 82 draws a 4:3 stage, so if the Pi sends a widescreen mode, the stage gets squashed. The Pi has to output 640×480. On current Raspberry Pi OS the old hdmi_group and hdmi_mode lines in config.txt are dead; the kernel takes its orders from cmdline.txt, and the desktop then picks its own mode on top of that. So it takes two small files.

Append to the end of the single long line in /boot/firmware/cmdline.txt:

video=HDMI-A-1:640x480@60D vc4.force_hotplug=1

The D forces the output on even when nothing answers, and force_hotplug keeps it on if the modulator never raises the hotplug pin (mine does not). Then pin the desktop to the same mode in ~/.config/kanshi/config:

profile crt {
  output HDMI-A-1 mode 640x480 position 0,0
}

Without that second file, the desktop on my Pi happily chose 1024×768 on top of the kernel’s 640×480.

Give it an EDID, so there is sound

The first picture had no audio, and the reason is a good one: cheap modulators send no EDID, the little data block a screen uses to introduce itself. No EDID means the Pi does not know the “screen” can hear, and it refuses to send HDMI audio at all. So I made it one. The CABLE 82 repo now ships a 256-byte EDID that describes a 640×480 4:3 screen with stereo audio (edid/cable82-640x480-audio.bin, with the script that generates it). Hand it to the kernel:

sudo mkdir -p /lib/firmware/edid
sudo cp ~/cable-82/edid/cable82-640x480-audio.bin /lib/firmware/edid/cable82.bin

and add one more parameter to that same cmdline.txt line:

drm.edid_firmware=HDMI-A-1:edid/cable82.bin

Reboot. wpctl status now lists an HDMI sink next to the headphone jack; make it the default and give it some level (WirePlumber remembers):

wpctl status                       # find the "(HDMI)" sink's number
wpctl set-default <number>
wpctl set-volume <number> 0.8

The channel’s music came out of the Magnavox’s speaker on the next page turn.

Hide the cursor

A mouse pointer sat in the middle of the picture with no mouse attached. The HDMI CEC input counts as a pointer device, so the desktop draws one. The fix is a labwc keybinding that hides it, pressed automatically after boot. Copy /etc/xdg/labwc/rc.xml to ~/.config/labwc/rc.xml, add inside <keyboard>:

<keybind key="A-W-h"><action name="HideCursor"/></keybind>

then sudo apt install wtype and add to the end of ~/.config/labwc/autostart:

(sleep 10; wtype -M alt -M logo -P h -p h -m logo -m alt) &

The detour: composite

Before the HDMI modulator arrived I tried the other way in: the Pi’s 3.5mm AV jack, a 4-pole cable to yellow/red/white, and an old composite-to-RF adapter. On a Pi 3 that means sudo raspi-config nonint do_composite 0, which turns HDMI off; on every Pi before the 5 it is one or the other. The Wayland desktop also does not trust the composite connector until it is told the mode, so video=Composite-1:720x480@60ie,tv_mode=NTSC goes on the cmdline.txt line too.

Step 6: Make it readable

With everything working, the verdict on a 9-inch 1987 tube over RF: the big clock and the crawl read fine, the small text was marginal, and the red and blue pages were worse than the cyan one. That is NTSC. It smears saturated color, it clips pure white (broadcast engineers kept white at 90% for a reason), and the hard drop shadow under every character turned into ringing.

So I added a CRT set of settings in the control room for much older TVs…

• CRT mode swaps in a softer palette (less saturated backgrounds, 90% white) and drops the drop shadow.
• Text size enlarges the body text, kicker, crawl, and the small header lines, from 1 to 1.5x. I run 1.25 on this set; the big clock stays as it is.
• Overscan safe margin was already there; raise it if the TV crops the edges.

Turning text size up found one more thing: at 640×480 the weather card no longer fit and its HI/LO line slid under the crawl.

So pages now fit themselves: if the content would overflow, the weather card gives up its sunrise/sunset line first, then shrinks just enough, and a long fact does the same.

All of that is in the repo as of this post.

What changed because of this build

Three things fed straight back into the project:

• The original post now carries a dated update: the kiosk command is chromium in ~/.config/labwc/autostart on current Raspberry Pi OS, and the power supply got the mention it earned.
• The repo README was rewritten from this build, step by step as tested, with a Troubleshooting section keyed to the exact errors from the comment thread.
• CABLE 82 itself gained CRT mode, the text size setting, the fit-to-page behavior, and the shipped EDID, because a real 1987 tube demanded all four.

That is the part I did not expect when a reader said “localhost refused to connect”: the failure report turned into the best test pass the project ever had!

A channel of your own

The Magnavox sits there now, tuned to channel 3, being a channel. The clock, the bake-sale energy, the crawl, the beautiful-music bed coming out of a mono speaker that was built when the music was new. It is a thirty-nine-year-old TV showing a channel that stopped existing before the TV was built, fed by a computer the size of a deck of cards, and the whole thing works because somebody left a comment saying it did not.

So: if you build one and it refuses to connect, say so. That is how this channel gets better, and it is very 1982 of you. Thanks.

What you need

Any of the big three AI chatbots, all of which have free tiers:

• ChatGPT
• Claude
• Gemini

They’re all good at this. Wordplay, puns, and pop-culture mashups are the kind of thing these models genuinely enjoy (if models can enjoy things).

The original version of this tutorial pointed to a custom GPT I built for exactly this job. You don’t need it anymore. You don’t need a name-generator website either. The base models got good enough that the wrapper became the long way around, and a plain chat with a decent prompt beats both.

The method

The 2024 version had a warm-up step where you told the AI your objective and asked it to respond OKAY before sending the real prompt. You can skip that now; the models don’t need to be eased into anything anymore. Everything goes in one prompt, and the whole method is three steps:

1. Open a new chat in ChatGPT, Claude, or Gemini.
2. Pick a prompt template below, replace the [BRACKETED] words, and send it.
3. When a direction makes you grin, ask for more: “give me 10 more like #3” works exactly like you’d hope.

The 20 prompt templates

1. Generate 5 funny fantasy football team names based on [PLAYER NAME]’s name or playing style.
2. Create 5 clever fantasy football team names inspired by the [TEAM NAME] and their history or current roster.
3. Come up with 5 witty fantasy football team names centered around [POSITION] players.
4. Blend NFL references with [MOVIE/TV SHOW/BOOK] to create 5 unique fantasy football team names.
5. Generate 5 punny fantasy football team names using football terminology and common phrases.
6. Create 5 alliterative fantasy football team names starting with the letter [LETTER].
7. Combine [CITY/STATE] references with football terms to make 5 locally-themed fantasy team names.
8. Generate 5 playful trash-talking fantasy football team names that imply dominating the competition.
9. Create 5 fantasy football team names that blend [PROFESSION] terminology with football references.
10. Come up with 5 fantasy football team names that incorporate [HOLIDAY/SEASON] themes.
11. Generate 5 appetizing fantasy football team names that combine [FOOD] with player names or football terms.
12. Create 5 fantasy football team names that blend [MUSIC GENRE/ARTIST] references with NFL players or teams.
13. Combine names of [HISTORICAL ERA] figures with football terminology to create 5 unique team names.
14. Generate 5 epic fantasy football team names inspired by [MYTHOLOGY] and NFL players or terms.
15. Create 5 geeky fantasy football team names that combine [SCIENTIFIC FIELD/TECH COMPANY] with NFL references.
16. Come up with 5 colorful fantasy football team names incorporating [COLOR] and player names or football terms.
17. Generate 5 wild fantasy football team names that blend [ANIMAL SPECIES] characteristics with NFL players or terms.
18. Create 5 electrifying fantasy football team names inspired by [WEATHER EVENT] and football references.
19. Blend elements from [FICTIONAL WORLD/UNIVERSE] with NFL references to create 5 fantastical fantasy football team names.
20. Generate 5 multi-sport fantasy football team names that combine NFL references with terms from [OTHER SPORT].

An example

My go-to demo is template #4: “Blend NFL references with Deadpool to create 5 unique fantasy football team names.” The best result it ever gave me is still Mercs with a Mouthguard, riffing on Deadpool being the Merc with a Mouth in the comics. That one made the jump to a real league.

The new trick: make it about your league

This is the part that didn’t exist in the original tutorial. A name-generator website hands everyone the same list. The AI can work with your league specifically. Paste in your context along with the template:

Here are the other team names in my league: [PASTE THE LIST]. I finished [YOUR FINISH] last season, and I just drafted [YOUR KEY PLAYERS]. Generate 5 fantasy football team names that fit this league and gently roast my rivals.

Names that reference your buddy’s decade-long championship drought hit different than anything a template can produce. This also works for the sadder traditions: ask for last-place punishment team names and it delivers those too.

Bonus: generate a logo

In 2024 this step required a separate image tool. Now ChatGPT and Gemini generate images right in the chat, so once you’ve picked your name, keep going:

Create a fantasy football team logo for “[YOUR TEAM NAME]”: bold, cartoon mascot style, sized for a league avatar.

Ask for two or three style variations and pick the one that looks best at thumbnail size, because that’s the only size your league will ever see it.

The name is the only part of your season you have full control over…

Appendix: 100 names that survived the cull

One more thing, since the whole post is about the method: I ran it on itself. A few hundred generated names across ten different template directions, then a hard cull of anything that sounded like it shipped with a default league. These 100 survived, each with the recipe behind it so you can find your player or your favorite reference. Steal freely; your league never has to know.

Quarterback puns

Running back puns

Pass catcher puns

Movie and TV mashups

Music mashups

Science and tech

AI-era names

Myth, history, and literature

Group chat trash talk

Deep cuts and current events

That problem I had hasn’t changed, but the best answer has. Live Server went years without maintenance, and in early 2026 a critical security vulnerability in its dev server was publicly disclosed before it finally got a patch. Meanwhile, Microsoft now ships a first-party extension that does the same job: Live Preview. Same right-click workflow, actively maintained, and it’s what I use now.

Why you need a local server at all

Open an HTML file from disk and the browser loads it with a file:// address. That works right up until your page tries to fetch a file, load a JavaScript module, or play audio. Then the browser blocks it, for security reasons. Your code isn’t broken; it just needs to be served over HTTP like a real website. A local development server does exactly that, on your own machine, at an address like http://127.0.0.1:3000.

The quick answer: Live Preview

Live Preview is Microsoft’s extension for exactly this.

1. Open the Extensions panel (Ctrl+Shift+X), search for Live Preview by Microsoft, and install it.
2. Open your HTML file.
3. Right-click in the editor and choose Show Preview.

You get a live browser panel right inside VS Code, and it refreshes automatically as you type. When you want the full browser experience (developer tools, real window size), use Show Preview in External Browser instead, or just open the http://127.0.0.1:3000 address it prints.

What happened to Live Server

The original version of this post recommended the Live Server extension by Ritwick Dey, and 80 million installs say I wasn’t alone. It still works, and the workflow is nearly identical: right-click the file, Open with Live Server, or hit the Go Live button in the status bar.

But the extension went years without maintenance, and in February 2026 a critical vulnerability (CVE-2025-65717) was publicly disclosed: visit the wrong webpage while Live Server is running, and that page can quietly pull files off your machine through the extension’s local server. Source code, config files, .env secrets, whatever the server can reach. Security researchers had been trying to reach the maintainer since mid-2025; the patch (version 5.7.10) landed only after the story went public. If you have Live Server installed, make sure it’s updated to 5.7.10 or later. Better yet, switch.

No extension at all

If you’d rather not install anything, you already have a server or two on your machine:

# Node
npx serve

# Python
python -m http.server 8000

Run either one in your project folder and open the address it prints. You lose the auto-refresh, but for a quick test it’s hard to beat.

Debugging

Once the page is served, the browser’s developer tools (F12 or Ctrl+Shift+I) work exactly as you’d expect: console, breakpoints, network tab, the works.

The original post suggested installing the “Debugger for Chrome” extension to debug from inside VS Code. You don’t need it anymore; JavaScript debugging is built into VS Code now. Create a launch.json with a chrome or msedge configuration pointed at your local server URL, hit F5, and set breakpoints right in the editor.

The game, by the way

Shoot shipped with sound! Play it here: https://shoot.nothans.com/

As soon I as I heard that there would be a surpsise reveal of the new pinball machine, I wanted to try it. It was in the Crawl Con room by Rengade Games in the Indiana Convention Center.

What is Dungeon Crawling Carl?

Well, you are about to hear about it from everyone you know. Buckle up.

Dungeon Crawler Carl is a wildly popular LitRPG series by Matt Dinniman that kicks off with a guy named Carl running outside in nothing but his boxers, a leather jacket, and his ex-girlfriend’s tight pink Crocs to catch her prized tortoiseshell Persian cat, Princess Donut. That wardrobe choice saves their lives: seconds later, aliens flatten every building on Earth, killing everyone indoors.

The survivors are herded into a colossal underground dungeon and forced to fight their way down floor by floor. The entire death trap is broadcast across the universe as a massive reality show, meaning sponsors, fan popularity, and audience bloodlust dictate who lives or dies. Carl teams up with Donut, who gains human speech and immediately weaponizes her pampered show-cat ego to manipulate the galactic viewers. Meanwhile, the dungeon’s AI develops a weird, sadistic foot fetish and actively refuses to give Carl decent lower-body armor, forcing him to fight off monsters while basically half-naked.

Because it’s LitRPG, the story includes video game mechanics like stat screens, loot drops, and system notifications. But it works perfectly as both a genuinely tense survival story and a hilarious, deeply angry satire about corporate greed and the entertainment industry. If you get into it, I recommend the audiobook. They are narrated and voiced by Jeff Hays. His performance is so good.

What is Dungeon Crawler Carl Pinball?

Dungeon Crawler Carl is a pinball machine based on the Dungeon Crawler Carl book series, written by Matt Dinniman. You play as Carl, accompanied by Princess Donut, navigating the various dungeon levels and all of the dangers and challenges it presents. Fighting mobs, battle bosses, cast spells, build your viewer count, collect friends, and figure out how to not just survive in the dungeon, but also how to get vengeance! Every aspect of the game combines to immerse you into the story. This includes a host of thematically integrated interactive mechanisms, an audio experience led by Jeff Hays voicing all of the characters, new artwork from Luciano Fleitas, Brad Albright, as well as other Dungeon Crawler Carl artwork shared by Renegade Game Studios, and game rules that connect you with all of the major events and plotlines and many of the minor plotlines as well.

After getting a chance to see the surprise reveal of the game, I got my own surprise. Matt came out to hang with the pinball players and talk about the weather… I MEAN DUNGEON CRAWLER CARL. Matt kicked off something bizarae and sweeping. Like I said, buckle up!

On my journey, I met Tasker Smith. Right from the start, Tasker had a unique point of view about pinball and life. He didn’t slam the machine, but he also had feelings about getting better. He turned failures into lessons and was always awesome to play with. Then, he says he is writing a book. And, a very Tasker thing to do is to actually write a little bit a time and couple of years go by you have a book, then it is is getting published, then he is on a book tour.

Pinball: A Quest for Mastery is about pinball, but it is also philosophy. The book is not about being a master at pinball; it is about being on the quest. The book shares history, demystifies rule complexity, gives you a primer for understanding the game, and what it takes to get better and why. I feel Tasker just shares a user manual with us on how to approach any hobby or pursuit.

I recommend the book for players of all skill levels. I find myself opening the book, flipping to a section, and learning something interesting no matter where I read. This also echoes one of Tasker’s viewpoints: take every moment to learn, get better, and make your own luck. The book is filled with advice and resources. The book doesn’t leave you feeling alone. I thoroughly enjoyed the read!

Go to your friendly local bookstore and pick up a copy.

Congrats, Tasker!

The results are gorgeous! I learned a lot and will share more of the details when I get time. You can follow the live build here: https://pinside.com/pinball/forum/topic/atari-superman-playfield-wall-art

Inserts and Plastics

When I got the playfield home, I realized that I didn’t have the complete playfield. I only had the wood and the printed art. Every insert, plastic piece, and post was removed. The original owner was planning a playfield restoration and had stopped at some point. The artwork was touched up and looked beautiful, but probably would not work for playing pinball on it. The inserts were going to be important since my goal was to place an LED behind them to make them glow.

I put out a post on Pinside looking for any old parts for the Atari Superman Pinball and got a few bites.

Soon enough, I got the original parts for this exact playfield. I got to meet up with the pinhead that donated the playfield to the museum. We chatted for hours about 70s and 80s pinball, swapped stories, and made a community connection. It was surreal to find the original owner, but the pinball community is a small niche hobby.

I also found the original Superman plafield plastic pieces. They shined right up with Novus Plastic Polish. The Novus cleaning products are a must if you work on pinball machines.

To mount the plastic pieces on the playfield, you need post mounts and post stud screws. The mounts were easy to find, but the stud screws were a challenge. New ones were about a dollar each. So, this didn’t scale well. I needed like 60 of them, so if my math is right, that’s $60. I turned to eBay and found someone selling “pounds of old pinball parts”. This came in at $90! Look at the savings. Somehow, I felt better about buying old used parts than buying new ones at a lower price… and in the process, I got a bunch of rusty parts I didn’t even need.

My old screw bucket was not happy that I bought someone else’s old screw bucket and didn’t even consult it.

Mounting all of the playfield parts took a lot of time, but you just do one at a time. I have a new respect for anyone who designs these things. 70s pinball was so much simpler than modern pinball machines, and it was still a lot of parts to track.

Flippers

I wanted to complete the top side of the playfield with flippers. So, I took old flippers from my Strikes and Spares pinball machine and cut them down for this build. Again, this will be wall-mounted, so you can’t have things sticking out too far in the back. They needed to be modded, and Dremel came to the rescue. Shooting a 6-foot stream of sparks across the room.

LED Control and CheerLights

Of course, it is connected to the CheerLights project. This was going to happen 100% of the time whenever I connected 150 LEDs to something. I used WS2811 bullet-style LEDs that you can control one at a time. They fit perfectly in the 12.5mm general illumination holes in the playfield. I used a WLED controller and a 3A power supply to control the colors, animations, and synchronization with the CheerLights MQTT server.

The insert near the flippers stays in sync with the latest CheerLights color while the rest of the inserts can have their own color or visual effects.

Out of the box, the best animation effect was Stream 2. This very much looks like an attract mode on a pinball machine.

3D Models

Part of the project was making my first 3D model to have the original pop bumpers mounted above the playfield but not connected to the original mechanism. Since this is wall art, I can’t have a mechanism sticking out 7 inches on the back. I also could not find the old-style pop bumpers on Maker World, so I designed my own… ish. Meaning it is not a pop bumper for function, it is a pop bumper to take light from an LED and let it shine through. I just published my first model!

For other parts needed, I found a person on Pinside who created a system called PinGlow. They were way ahead of me and had thought through the kind of stuff you are going to need for a wall art project like mine. They offer drop targets, stand-up targets, wall mounting kits, and even LEDs. I reached out to them on Pinside, and they offered to make a custom version of their drop targets specifically for the Atari Pinball machine. These drop targets had the Superman logo on them.

Project Demo