BOOKSOLE v0.5 — It Finally Feels Like a Real Thing

For a while, BOOKSOLE could load interactive books, parse them, and let you navigate choices, but it still felt like a tool. Functional, but not something with an identity.

This update was about changing that.

The biggest addition is the new library system. Instead of dropping straight into a book, you now land in a cartridge-style library where every story lives on a shelf. You can browse covers, check metadata, see your progress, and launch a book like you’re pulling a game off an old console rack.

That shift sounds small, but it completely changed how the project feels.

The other thing I spent an unreasonable amount of time on was the intro sequence.

I could have gone with a simple splash screen, but instead I ended up building a fully animated pixel-art opening scene from scratch. Every character, prop, and background element is drawn procedurally on a canvas. Max, Victor, the mysterious cartridge, the old CRT aesthetic—it’s all there.

Was it necessary?

Absolutely not.

But it was fun, and BOOKSOLE is the kind of project where atmosphere matters.

After the intro, the application now boots like a retro console. There’s a fake startup sequence, loading messages, scanlines, pulsing graphics, and all the little details that make it feel like you’re powering on a strange forgotten machine rather than opening a web app.

I also added a proper book details screen. Books now have their own dedicated page with cover art, author information, descriptions, tags, and progress statistics. It makes imported stories feel more like collectibles and less like files sitting in a folder.

On the gameplay side, save slots finally arrived.

This was something I wanted from the beginning because gamebooks are all about experimentation. Sometimes you want to make the reckless choice just to see what happens. Multiple save slots make that possible without destroying a perfectly good run.

To support replayability even more, I built an ending discovery system. BOOKSOLE now keeps track of endings you’ve found and visualizes them through a simple ending map. Good endings, bad endings, weird endings—you can slowly fill out your collection as you explore different routes.

There’s also a lightweight achievement system now. Nothing too serious, just a way to track things like choices made, pages visited, endings discovered, and total runs. It’s a small thing, but it reinforces the idea that reading these books is closer to playing a game than reading a novel.

Another feature I’m surprisingly happy with is the journal.

While testing branching stories, I kept finding myself taking notes elsewhere. So now BOOKSOLE has a built-in journal where players can leave thoughts, theories, and route notes while they play. It feels especially useful for mystery stories or books with hidden paths.

A few quality-of-life improvements made it in too:

• Search across story pages
• Adjustable font sizes
• Backtracking through visited pages
• Import/export support for saves and progress
• Better organization of runs and statistics

Looking at the project now, it finally feels like the original vision is starting to come together.

The idea was never to build another ebook reader.

The idea was to build a fictional retro console dedicated entirely to interactive fiction.

A place where opening a book feels like inserting a cartridge.

Version 0.5 is probably the first release where that idea actually comes across.

Next up, I’m focusing on better EPUB support, smarter metadata extraction, richer achievement systems, and generally making the stories themselves feel more alive inside the platform.

But for now, I’m pretty happy with where BOOKSOLE is.

It’s weird.

It’s overly nostalgic.

And it’s finally starting to feel like its own thing.

Added a new Home Screen and an intro story

Devlog 2

Added a boot screen and implemented a proper parser. I tested it with Give Yourself Goosebumps #15: Don’t Feed the Vampire, and it worked very well. This was a major milestone and greatly increased my confidence in the project.

My next goal is to add support for user-created stories so that players can create and share their own interactive adventures. This will make the project more flexible and allow the community to contribute new content.

When Books Become Cartridges

A self-hosted, browser-based book console where your CYOA novels are the game.

I’ve been thinking about what it would look like if the “Give Yourself Goosebumps” series never stopped being a game. You’d pick up the book, flip to a page, make a choice, flip again — and the whole time it felt less like reading and more like playing. The book was the cartridge. You were the console.

That’s the idea behind Booksole.

What is it?

Booksole is a , single-file HTML app (for now)that turns choose-your-own-adventure books into playable games — complete with save slots, multiple playthroughs, auto-generated achievements, and an endings tracker.

You drop in a plain .txt copy of your book. The app parses it, maps out all the branching paths, counts the endings, and boots it up like a game cartridge being slotted into a console. No server. No sign-up. No subscription. Just a file in a browser.

The whole thing runs locally. Your books never leave your device.

The Inspiration

R.L. Stine’s Give Yourself Goosebumps series was my first experience with non-linear storytelling. You weren’t just reading — you were playing. Every “turn to page 52” was a decision with consequences. Some paths led to victory. Most led to something horrible. And the thrill was in finding all of them.

Modern games have achievements, save states, completion trackers. Why don’t books?

Stardance answers that question. It treats your book like a game ROM. It reads the branching structure, builds a graph of every page and decision, and wraps the whole thing in an interface that feels like a retro console — monospace font, dark terminal aesthetic, endings map, achievement popups.

Every book you upload gets its own automatically generated achievement list based on its structure: find your first ending, reach a good ending, discover all the bad endings, finish in three choices or fewer. The game figures out what’s achievable by analyzing the book itself at parse time.

v0.1 — What’s in it

Cartridge loading — drop a .txt file and the parser scans for page markers and “turn to page X” instructions, rebuilds the branching tree, and launches
Multiple save slots — run through the book multiple times simultaneously, each as a separate playthrough
Endings map — a dot grid showing every ending in the book, colored by type (good / bad / neutral), filling in as you discover them
Auto-generated achievements — built from graph analysis at load time, no hand-crafting needed
Achievement toasts — unlock notifications that feel like a game, not a reading app
Session stats choices made, pages visited, play throughs started, endings found Persistent saves everything lives in localStorage, survives page reloads the entire app is one .html file, no build step, no dependencies, no installing any software

If any one has any suggestions on any features to add or any technologies that could be incorporated to make the development or the user experience easier please do give feedback