Bubble software, literally!

How Konami used this unusual bubble technology in their games.

https://www.youtube.com/watch?v=DVJ9ED8mWt0

#retrogaming #retrocomputing #konami

zenimate supports sprites of up to 32x24 cells (256x192) which is the size of a standard Spectrum screen, and it can import png, jpeg, and gif images (best fit, centre, and stretch modes). Conceivably, you could draw interesting animations to use in your own Spectrum software. Which is a good reason to work on screen compression with fast decompression and exports that you can drop in your game code. Status: being designed for an upcoming release.

https://github.com/ha1tch/zenimate/releases/tag/v0.6.1

#ZxSpectrum #spectrum #speccy #retrocomputing #retrogaming #golang #foss #pixelart #zenimate

NEW: zenimate 0.6.0 — first release

A paint and animate editor of ZX Spectrum sprites, written in Go.

Draw multi-frame sprites on a pixel grid, paint real per-cell Spectrum colour
attributes (ink/paper/bright), and preview the animation. Up to a full screen
(32×24 cells) and 1–16 frames. Frame flips/rotate, onion-skinning, screen &
image import, .zani/.zbun files.

The desktop editor is a raylib app rendered entirely in the Sinclair ZX Spectrum font. Terminal editor + player included too.

Prebuilt binaries for Linux (amd64/arm64, incl. Raspberry Pi), macOS
(Intel + Apple Silicon), and Windows.

https://github.com/ha1tch/zenimate

#ZXSpectrum #retrocomputing #golang #pixelart #gamedev #foss #Spectrum #pixelart #speccy

Minizork for the ZX Spectrum, 1988

#ZXSpectrum #Spectrum #speccy #retrogaming #retrocomputing #textadventure #interactiveFiction

I like high resolution desktops, mid resolution terminals, and low resolution games.

I was finally able to correct my emulator, ZenZX, to make it work with ZX Spectrum +3 floppy discs which weren't so floppy. With many thanks to @FromTheFourthPlanet for her wonderful emulator, SpecIde, I learned massively from her generous gift and her deep knowledge of the machinery involved.
https://github.com/MartianGirl/SpecIde

Now I'm able to load The Artist II by Ocean Software from a DSK image. I wasn't able to draw f** s** using its keyboard layout. Here's a dodgy invader for you.

#pixelart #theartist #ZXSpectrum #Spectrum #Speccy #retrocomputing #zenzx

Introducing ZenZX v0.2.0

a ZX Spectrum emulator in Go, first public release.

Emulates 48K, 128K, +2 and +3, based on the zen80 Z80 core.
Two builds: a GUI emulator, and a CGO-free headless mode that boots a machine model, runs N frames, and dumps PNG screenshots — handy for testing Spectrum software without a display. Many games are known to work already (Bruce Lee, Head Over Heels, Batman, Jet Set Willy, Manic Miner, tested... "for science"). Known issues: snapshots, fast load, and sound are bad.

https://github.com/ha1tch/zenzx

#ZXSpectrum #retrocomputing #golang #emulator #Z80 #retrogaming #foss #Spectrum #Speccy #retrogaming

I think about three or four years have passed since I made this chart, it may be needing an update.

#ZXSpectrum #Speccy #Spectrum #retrocomputing #retrogaming

Lovely NeXT keyboard close up

via aresluna

https://aresluna.org/show-your-hands-honor/

#keyboard #retrocomputing #NeXT #vintageNeXT

I don't want to be too pessimistic about the Commodore Vega, and maybe I'm at fault for lacking ambition in that particular direction, it's just that I can't imagine myself wanting a second phone to get more calls, and chatting on it more.

Is this retrocomputing enough?

https://mastodon.social/@gutenberg_org/116741963596097407

@jimblimey Hey Mr Blimey, just saw this; may be up your alley

https://www.youtube.com/watch?v=DqM_SHJ8TTg

Popular Computing Weekly, week of 3-9 February 1983

"The artifical intelligence language is contained in just over 7k of code"

https://worldofspectrum.org/archive/magazines/popular-computing-weekly/5/2/1983/2/3#4

#retrocomputing #lisp #zxspectrum #speccy #spectrum

Release: fsm-toolkit v0.9.5

fsm-toolkit is a Go toolkit for designing and analysing finite state machines. It provides a CLI tool (fsm) and a full TUI editor (fsmedit) supporting DFA, NFA, Mealy, and Moore machines — with multi-machine bundles, cross-machine linking, and a component system backed by reusable class libraries.

Repo:

https://github.com/ha1tch/fsm-toolkit#readme

This is the biggest release since the project's inception bringing a component-oriented workflow to FSM design. You can now drag 74xx-series digital logic parts from a library drawer, assign typed properties to states, link machines into bundles, and manage it all from the TUI. Builds and releases for 12 platforms are now fully automated.

New: Editor Manual

https://github.com/ha1tch/fsm-toolkit/blob/main/cmd/fsmedit/MANUAL.md

New: Workflow Guide

https://github.com/ha1tch/fsm-toolkit/blob/main/WORKFLOWS.md

Highlights

% Multi-document bundles with import and cross-machine navigation
% Class and property system with 7 typed fields
% Component drawer with drag-and-drop instantiation
% 74xx-series class libraries (49 components across 7 families)
% Machine manager with rename/delete and link propagation
% Settings screen with vocabulary customisation and library loading
% Improved TUI layout engine with cell-grid metrics
% CI/CD pipeline targeting 12 platforms (Linux, macOS, Windows, FreeBSD, OpenBSD, NetBSD)
% Separate CLI and editor manuals
% 261+ tests passing

Changelog:

https://github.com/ha1tch/fsm-toolkit/blob/main/CHANGELOG.md

#golang #foss #programming #compsci #fsm #digitallogic #tui #statemachines #electronics

ual news: ual is getting cual

The good news is that apart from the embedded systems targeted through TinyGo, the ual programming language is getting a tiny C backend called cual that allows us to target small machines, notably the Z80, with support for some of its most popular platforms: the ZX Spectrum and CP/M to get started with.

The bad news is that the weekend was too short and it's going to take me a while longer to release ual 0.7.6 the way I'd like.

#ual #programming #forth #rustlang #golang #foss #opensource #compsci #cpm #z80 #retrocomputing #zxspectrum #speccy #spectrum

Great post by Andrew Kelley

https://ziglang.org/devlog/2026/#2026-01-31

#zig #ziglang

FPGA for Arcades - "Multisystem 2 Arcade" Revealed

https://www.youtube.com/watch?v=g_4LXsOU23Q

#electronics #retrogaming #retrocomputing #fpga #gamedev

ual v0.7.5 released

ual is a systems language for orchestration and embedded computation. It now comes in three forms: two compilers (Go and Rust backends) and an interpreter. All three share the same semantics and produce identical results. This release adds a production-ready Rust backend and a threaded-code compiler for the interpreter.

https://github.com/ha1tch/ual

What's new

Rust backend with full feature parity — 92/92 examples produce identical output across Go, Rust, and interpreter. Rust binaries are 4× smaller (343K vs 1.3M stripped).

Threaded-code compiler for iual delivers 5–12× speedup on numeric workloads. The interpreter now beats Python by 4–13× while remaining a single-file tool for development.

Automatic target selection: if you have Go, it uses Go. If you only have Rust, it uses Rust. Write once, compile anywhere.

What makes ual different

Coordination is the primary problem; computation happens in designated islands. Data lives in typed stacks accessed through perspectives (LIFO, FIFO, Indexed, Hash). Time is explicit. Errors must be acknowledged.

Binaries available for:
Linux (amd64, arm64, arm, 386), macOS (Intel, Apple Silicon), Windows (64-bit, 32-bit), FreeBSD, OpenBSD, NetBSD

Release:
https://github.com/ha1tch/ual/releases/tag/v0.7.5

Docs:
https://github.com/ha1tch/ual/blob/main/docs/MANUAL.md

#ual #golang #foss #rust #rustlang #forth #programming #compsci

Using ual, a Forth programmer could be productive in a day, fluent in a week. The mental model transfers. The syntax requires adjustment, but it's not a paradigm shift, more like learning a dialect.

B... but... apart from the fast compute, Rust-optimised binaries, strong concurrency model, type safety, three-way backend parity, blocking stack primitives, named stacks with perspectives, compute blocks that rival C performance, cross-platform compilation, and not having to manually manage memory...

What have the Romans ever done for us? 🤣

ual v0.7.3 released

ual is a systems language for orchestration and embedded computation. It comes in two forms: a compiler targeting native binaries, and an interpreter for development. Both share the same runtime and produce identical results. This release marks the completion of runtime unification — the interpreter now has full parity with the compiler, including true goroutine-based concurrency, using Go as IR and bootstrapping tool.

https://github.com/ha1tch/ual

What makes ual different

ual is built on a specific philosophical foundation: that coordination is the primary problem of programming and that types and computation are subordinate within coordinated contexts. Data lives in typed stacks accessed through perspectives (LIFO, FIFO, Indexed, Hash). Time is explicit — blocking waits, timeouts are native. Errors must be acknowledged before proceeding.

Binaries available for:
Linux (amd64, arm64, arm, 386), macOS (Intel, Apple Silicon), Windows (64-bit, 32-bit), FreeBSD, OpenBSD, NetBSD

Release:
https://github.com/ha1tch/ual/releases/tag/v0.7.3

Docs
https://github.com/ha1tch/ual/blob/main/docs/MANUAL.md

#ual #golang #foss #rust #rustlang #forth #programming #compsci