RastaConverter https://github.com/ilmenit/RastaConverter is a graphics converter from modern computers to old 8bit Atari computers. In recent versions I added ability to generate two pictures blended together into a high-color output, leading to pictures with 800 or more unique perceived colors. The picture is displayed in graphics mode 15 (Antic Mode E) that has by default four unique colors.
The conversion process is optimization of the Kernel Program. It uses most of the Atari graphics capabilities including sprites, midline color changes and sprite multiplication.
Key capabilities:
- Extremely optimized emulator of subset of 6502 CPU and ANTIC to simulate execution on real machine.
- Optimization: Late Acceptance Hill Climbing (LAHC) and Diversified Late Acceptance Search (DLAS), with support for reproducible runs, evaluation limits, auto-save and resume.
- Dithering: chess, Floyd–Steinberg, random-Floyd, line,
line2, 2D, Jarvis, simple, and Knoll; tunable strength and randomness.
- Color distance: YUV (default), RGB Euclidean, CIEDE2000, and CIE94; independently selectable for preprocessing and optimization.
- Dual-frame mode: two alternating frames (A/B) with YUV or RGB blending, optional temporal luma/chroma penalties to reduce flicker, and export of both per-frame and blended outputs.
- Performance: multi-threaded execution with per-thread line caches and configurable cache size.
Considering that even simple neural networks are universal approximators, and that most of the intelligent tasks require prediction of the next state(s) according to previous state, aren't biological or artificial brains "just" universal approximators of extremely complex function of the world?
That’s true in a narrow functional sense, but it misses the role of a world model. Intelligence isn’t just about approximating input-output mappings, it’s about building structured, causal models that let an agent generalize, simulate, and plan. Universal approximation only says you could represent those mappings, not that you can efficiently construct them. Current LLMs seem intelligent because they encode vast amounts of knowledge already expanded by biological intelligence. The real question is whether an LLM, on its own, can achieve the same kind of efficient causal and world-model building rather than just learning existing mappings. It can interpolate new intermediate representations within its learned manifold, but it still relies on the knowledge base produced by biological intelligence. It’s more of an interpolator than an extrapolator: as an analogy.
Note that you'd also have to be somewhat more precise as to what the "state" and "next state" are. It is likely that the state is everything that enters the brain (i.e. by means of sensing, such as what we see, hear, feel, introspect, etc.). However, parts of this state enter the brain at various places and at various frequencies. Abstracting that all away might be problematic.
I did recently also a tool for prime numbers visualization:
https://ilmenit.github.io/prime-fold/
It's not only for visualization but also discovering of mathematical functions that generate or embed prime numbers using evolutionary algorithms and fitness functions. It has two modes:
PrimeFold Mode (2D Embedding): Enter or evolve two functions, f_x(n) and f_y(n), to map numbers to 2D points. Primes and composites are visualized differently. This mode helps you discover spatial patterns and structures unique to primes. Example: f_x(n) = n, f_y(n) = n^2 or simply n, n^2.
PrimeGen Mode (1D Generation): Enter or evolve a single function, f(n), to generate numbers. The app visualizes which outputs are prime and how many unique primes are produced. Example: f(n) = 2*n + 1.
Trying to stress-test LLM Agents on RetroArch codebase (quite complex, with a lot of conditional compilation) Gemini 2.5 Pro admitted lack of own capabilities. That's actually nice behavior that I'd expect to see more from other models that don't stop and make more and more mess.
Thank you for the feedback! I was thinking about the force forward mechanic and as it exists in mentioned game. In Pressure stepping back is defensive until reaching the edge of the board. The biggest problem with the current design I have with endgame when it's balanced to 1 token left on each side. This could be a draw, because it's in most of the cases is not possible to lead to surrounding the leftover token. With 2 to 1 left still (depending on a board setup) it's possible to dance around to avoid capture.
Do you have some proposal that would work in this game?
The proposed resolution scenarios on conflicting moves would make the "moves stuck" to often. My proposal would be to split move into two phases:
- simultaneous selection of moves (players select action at the same time)
- non-simultaneous execution of moves (with circular queue of order rotating each turn)
It's not a perfect solution, because in case of the conflict on the first move it gives advantage to first player in execution order, however many complex games (Chess, Go) allow to perform multiple moves before first conflicting move may happen. Some other (Tic Tac To, Othello) allow to make conflicting moves from start.
Keeping an eye on the execution order would give additional strategy layer for planning moves. I like also idea on resolution of conflict depending on the set "strength" of the piece, or annihilation of both when it's equal. This would also bring interesting complexity for decision making.
Actually with HellMood (one of the x86 sizecoding wizards the best known for https://news.ycombinator.com/item?id=23002874) we were working on a port to FreeDOS x86/FPU, but the personal time did not allow us to finish the port before the competition deadline. Quoting HellMood "i think now that a decent port is possible".
There are a few advantages of WASM/MicroW8 like ability to draw vertical lines, or a palette that can use 8bit RGB (while VGA has 6bits), but the x86 in 16bit real-mode has powerful short CPU and FPU instructions, and you can use code as data (e.g., for IEEE float constants) to further reduce the binary length.
Key capabilities: - Extremely optimized emulator of subset of 6502 CPU and ANTIC to simulate execution on real machine.
- Optimization: Late Acceptance Hill Climbing (LAHC) and Diversified Late Acceptance Search (DLAS), with support for reproducible runs, evaluation limits, auto-save and resume.
- Dithering: chess, Floyd–Steinberg, random-Floyd, line, line2, 2D, Jarvis, simple, and Knoll; tunable strength and randomness.
- Color distance: YUV (default), RGB Euclidean, CIEDE2000, and CIE94; independently selectable for preprocessing and optimization.
- Dual-frame mode: two alternating frames (A/B) with YUV or RGB blending, optional temporal luma/chroma penalties to reduce flicker, and export of both per-frame and blended outputs.
- Performance: multi-threaded execution with per-thread line caches and configurable cache size.
- Image pipeline: resize filters (box, bilinear, bicubic, bspline, Catmull–Rom, Lanczos3) plus brightness/contrast/gamma adjustments.
- Hardware control: fine-grained control over Atari registers, including enabling/disabling hardware sprites (players/missiles) per scanline.
- Details mask: provide a mask image to emphasize selected regions and bring out fine details in the result.
- Palette selection: choose target palette files via Adobe ACT to match different monitors and CRT settings.
- Cross-platform: CMake-based builds for Windows, MacOS and Linux, with scripted Profile Guided Optimization.
- Extras: scripts and generators to assemble Atari executables.