简体中文
EnglishWebsite review
This review may include AI-generated content and is not individually verified. Domain, certificate and other facts come from the observed data on this page.
What is nurpax?
nurpax is the personal blog of Janne Hellsten, where he writes mostly about projects in his GitHub account. The strongest focus is Commodore 64 development: the C64jasm assembler, debugging C64jasm projects with VICE and C64Debugger, 6502 programming tricks, sprites, PETSCII, SID audio, and demo effects. The archive also includes a Python argparse post and a 2024 blog update, so it is not strictly C64-only, but C64 tooling and low-level programming dominate.
It is best suited to retro-computing hobbyists and programmers who want technical write-ups rather than news or tutorials for beginners. A practical entry point is the series on C64jasm and the 6502 tricks post if you are writing or studying 6502 assembly; the debugging post is the natural follow-up when you need to run and inspect a project. Expect a small, personal archive rather than a regularly updated publication.
What is C64jasm and how does it differ from traditional C64 assemblers?
C64jasm is a Commodore 64 macro assembler created by Janne Hellsten and documented on his personal blog, nurpax. From the posts listed there, it is presented as "a new take on C64 macro assembling"—a tool for writing 6502 assembly with a macro system, with follow-up articles covering object literals and loading sprites, PETSCII and SID data. The blog also covers debugging C64jasm projects with VICE and C64Debugger, so it is meant to fit into a practical edit-build-debug loop rather than stand alone.
Where it differs from traditional assemblers
The page evidence supports differences in emphasis rather than a feature-by-feature comparison:
- Macros as the centrepiece. Traditional C64 assemblers support macros, but C64jasm is framed around a rethought macro approach, and the author devotes separate posts to object literals and asset loading. That suggests the intended workflow is to generate repetitive code and embed data through structured constructs rather than long boilerplate.
- Modern authoring conveniences. The presence of a post on Python
argparsealongside assembler topics points to scripting and tooling around the build, which is a different posture from assemblers whose documentation stops at opcodes and directives. - Debugging integration. Guidance on debugging C64jasm output with VICE and C64Debugger indicates the tool is designed to be used with emulator-based debugging, which matters more for larger projects than for small demos.
Choosing between it and a traditional assembler
If you are porting an existing codebase or following tutorials written for a long-established assembler, staying with that assembler avoids rewriting directives and macro definitions. If you are starting a new project with heavy code generation, sprite and charset data, or want a macro system that behaves more like a small programming language, C64jasm is worth evaluating. A concrete next step: take one routine from your current project—say, a sprite-loading block—and write it in C64jasm using its macro and object-literal features, then compare the source length and readability against your existing version. That side-by-side test will tell you more than a feature list.
How do I debug C64jasm projects using VICE and C64Debugger?
The site does not include the article body, so the exact steps are not documented here. What the page evidence does show is that Janne Hellsten wrote a post titled "Debugging C64jasm projects with VICE and C64Debugger" (February 22, 2021), so the intended workflow pairs the C64jasm assembler with the VICE emulator and C64Debugger. The general approach below is standard C64 development practice, not a description of features specific to this project.
What each tool does in a debug session
| Tool | Role when debugging a C64jasm build |
|---|---|
| C64jasm | Assembles your source into a PRG or binary and can emit a symbol/label file that a debugger can load |
| VICE | Runs the program on an emulated C64; its monitor lets you inspect memory, set breakpoints and trace execution |
| C64Debugger | Attaches to a running emulator and gives a visual view of memory, sprites, character sets and code flow |
A practical workflow
- Build with symbols. Configure C64jasm to output a label or symbol file alongside the PRG. Without symbols, breakpoints in the debugger are just raw addresses.
- Load the PRG in VICE and start it. For quick checks, VICE's built-in monitor is enough: set a breakpoint at a label's address, step through, and inspect registers and memory.
- Switch to C64Debugger when the problem is visual or timing-related. It is most useful for seeing sprite data, screen memory and raster timing at a glance, which is hard to read as hex dumps in the monitor.
- Isolate the fault. For crashes, break early and step until the PC goes astray; for wrong graphics, compare memory against what the assembler emitted; for timing glitches, watch the raster position around the code in question.
A concrete example: if a sprite appears at the wrong position, load the symbol file, break at the routine that writes the sprite registers, and check the values in VICE's monitor; then open C64Debugger to confirm the sprite pointer and data actually match. That splits the problem into "wrong value computed" versus "right value, wrong memory location."
For the author's own setup — including how he wires C64jasm output into VICE and C64Debugger — read the original post at nurpax, and consult the official VICE and C64Debugger documentation for current command-line flags, since those change between releases.
What 6502 programming tricks does the blog cover for Commodore 64 development?
The blog covers 6502 and Commodore 64 development through a set of posts that mix assembly-language technique with tooling. The most directly relevant entry is "Dirty tricks 6502 programmers use" (August 2019), which addresses the sort of unconventional coding shortcuts 6502 developers rely on. Around it, the blog builds a practical C64 workflow: "C64jasm - a new take on C64 macro assembling" (November 2018) introduces the author's macro assembler, followed by "C64jasm object literals" (July 2019) and "Loading sprites, PETSCII and SID with C64jasm" (June 2019), which connect assembler features to graphics, text and sound assets. Debugging is covered in "Debugging C64jasm projects with VICE and C64Debugger" (February 2021) and the earlier "C64 tool tricks (VICE and others)" (August 2018). Effect-level work appears in "Break down of a C64 demo effect" (June 2017) and the BINTRIS series, including "BINTRIS C64: Bad lines and flexible line distance" (June 2018), which deals with raster timing constraints.
This is the personal blog of Janne Hellsten, focused mainly on his GitHub projects, so treat it as a developer's working notes rather than a structured course. A reasonable next step for someone learning C64 assembly is to read the "Dirty tricks" post alongside the C64jasm introduction, then try the sprite, PETSCII and SID loading examples in a VICE session, using the debugging post when something breaks. For broader reference material, compare with community resources such as Codebase64 or the official VICE documentation.
How can I load sprites, PETSCII, and SID music with C64jasm?
The page's post list includes "Loading sprites, PETSCII and SID with C64jasm" (June 6, 2019), which is the author's own walkthrough of that exact task. Start there, then use the earlier "C64jasm - a new take on C64 macro assembling" (November 8, 2018) for the assembler basics it assumes, and "C64jasm object literals" (July 27, 2019) for how assets are described in source.
What to expect from the approach
C64jasm is a macro assembler, so the loading workflow is built around declaring assets in assembly source and letting the build step place them. In practice that means three separate jobs:
- Sprites: binary data with a fixed byte layout (pointer table, then 63-byte sprite blocks), so you need the data at a known address and the VIC-II pointers set to match.
- PETSCII: screen codes or character data, which differ from ASCII — a common source of garbled output if the wrong table is used.
- SID music: a player routine plus the tune data, called once per frame from your interrupt or main loop.
The trade-off is control versus convenience: doing this in the assembler keeps everything in one build and reproducible, but you handle addresses and memory layout yourself rather than relying on a loader.
A concrete next step
Pick one asset type and get it on screen before adding the others. For a first pass, load a single sprite: confirm the data address, set the sprite pointer, enable the sprite, then move it — that verifies your build pipeline end to end. Add PETSCII text next, then SID last, since music brings in the player's own memory and timing requirements.
For background on the underlying hardware behaviour, the author's "Dirty tricks 6502 programmers use" (August 18, 2019) and "Break down of a C64 demo effect" (June 7, 2018) are useful companions, and the debugging post on VICE and C64Debugger (February 22, 2021) covers checking memory once assets are in place. The project itself lives at GitHub under the author's account; the site is nurpax.
What does the BINTRIS C64 series teach about bad lines and flexible line distance?
The series is a hands-on look at how the Commodore 64's video hardware constrains a real game project. The post "BINTRIS C64: Bad lines and flexible line distance (series part 5)" sits within a multi-part build log for BINTRIS, a Tetris-style game for the C64, published on Janne Hellsten's personal blog nurpax. The surrounding posts—on C64jasm (his macro assembler), sprite/PETSCII/SID loading, and debugging with VICE and C64Debugger—show the series is written for people who actually write 6502 code, not just read about it.
What "bad lines" means in this context
On the C64, the VIC-II chip must steal cycles from the CPU on certain raster lines to fetch character and sprite data. These are the "bad lines," and they reduce the CPU time available on those scanlines. For a game like BINTRIS that needs to update the playfield, sprites and timing-sensitive routines, knowing when those stolen cycles occur is the difference between smooth motion and glitches. The series treats this as a practical scheduling problem rather than pure theory.
Flexible line distance
The phrase points to controlling how many raster lines sit between repeated screen elements—useful for effects and layouts that don't fit a fixed character-row grid. By adjusting the vertical spacing, you can tune where drawing work lands relative to the bad lines, spreading CPU load and avoiding collisions with the cycles the VIC-II takes.
Who gets the most from it
- 6502 assembly programmers building raster-timed effects or action games on the C64.
- Homebrew developers using C64jasm who want their assembler workflow to match the hardware's timing.
- Learners moving from "make a sprite appear" to "make it appear at the right moment every frame."
A sensible next step is to read part 5 alongside the earlier parts in order, then open the C64 tool-tricks and debugging posts to reproduce the timing in VICE and step through it with C64Debugger. That combination—concept, assembler and debugger—is what turns the bad-line discussion into something you can verify on your own machine.
Amazon Route 53
Fastly
User reviews (0)