Talewright - Yet another framework

Hey folks,

I know the exhaustion must be real. I deal with it at work. The proliferation of everything with AI is taxing us all. Yes, AI implemented most of the code. I’ve reviewed every line of it, and I’ve made every architecture decision. Enough nerd talk. We’ll get to that later.

Let me tell you a tale of how this thing got started. I’ve been a writer my whole life. I actually started writing code before I started writing stories because, well, the language in programming is more limited, stricter, and easier to grok as a 10 year old. As I got older, that love of writing extended to real human language. It’s my favorite art.

I’ve had a story knocking around my head for the last 4 years. I’ve written lots of stories, and I’ve thrown it all away. I was determined to write this one. I knew I wanted it to be text-based. I knew I wanted it to be interactive. I knew I wanted it to be an RPG. I’ve been a DM/GM for a long time, and writing massively branching, on-the-rails type of campaigns has always been something that brings me great joy. The pain of writing for a table-top is that humans are a bunch of rogues who delight in derailing your shiny new locomotive.

Enter the story. I’ve been playing text based interactive fiction for a long time. I’m always looking for fun new stories, and I’ve run across plenty of good games that had me hooked until I hit a weird state bug or a scene that dead-ended or ran into a scripting issue. I have nothing but respect for the established systems that are commonly used, and those are what led me to create Talewright.

Talewright is heavily inspired by Ink, Twine, and ChoiceScript. Ren’py is also an inspiration, but I wanted to take it a different direction.

So what is Talewright? It’s a ground up, self-contained writing system that’s designed to stay simple. If all you want is a branching narrative, you don’t have to do anything else. You can make an entire story with just prose and diverts.

Here’s an example of the syntax:

=== the-beginning
@title The Beginning

The world blurs into existence. It's Thursday, you think. Hard to tell with the way the week has been going. You sit on the couch wondering what you had to do tonight.

Laundry? Yeah. That never ends. Dishes? Sure, the sink is a bottomless pit of hunger. Bills? Yup, got a whole stack of them right there.

Oh, right. You wanted to post about your new system, and you're worried it's not perfect.

"It'll never be perfect", the little voice in your head says.
"But it must be perfect", the big, ugly voice in your head says.

You hover on the forum, terrified. You're reading about release after release. AI this; AI that. Compilers, javascript, python, it's all a blur.

You wonder... Are authors actually clamoring for another tool?

* [Hell yeah they are] -> post-that-bad-thang
* [Eh, maybe not tonight. Could be more perfect] -> close-your-laptop

=== close-your-laptop
@continues

The big ugly voice wins. It needs to be more perfect. You can't post it tonight. You close your laptop, curl up in bed, and put on some brainless anime

-> END

=== post-that-bad-thang
@continues

Ya know what, maybe people do have the appetite for one more. You've put your heart and soul into this. You bolster yourself with the knowledge that you've made something that you're proud of, and you think it's worth posting.

The little voice inside your head lets out a tiny, squeaky cheer. You did it. You finally published something. You've made it real.

~ player:pride += 5

-> END

My first and only author test that wasn’t me was my 11-year-old. He was able to follow the docs, get his editing environment set up, write a story, and report some bugs that would have been a real pain.

My concept is that stories start simple and grow in complexity with the author. Authors should never have to write “real” code. Talemark - the custom DSL that powers Talewright - provides all the primitives most folks need to do complex things. State is handled for you. Hubs enable you to gather choices based on tags and conditions of varying complexity.

You don’t need anything other than a text editor to build and play a game. The files are local. The stories are yours. If you want to publish a story as a desktop application or a web hosted bundle, there’s a separate CLI that you can use to publish a fully self-contained, cross platform game.

Did I mention there’s RPG mechanics built in? By default, they’re disabled if you don’t want to write an rpg. If you do want to write an RPG, you simply flip a flag in the story manifest to enable it. You define characters, variables (text, numbers, or true/false), flags (only true/false), pronouns, items, factions, attributes, skills, triggers, and more in the manifest.

Images go in their own directory. More on that in the sample stories. The manifest for the “game” above would look something like this

game:
  id: post-it
  title: Post it. Or don't
  version: 1.0.0
  start: the-beginning

# This turns on the RPG features
# ruleset: 
#   base: rpg

  characters:
    player:
      pronouns: he
      first-name: Squid
      last-name: Farm

That’s all you need to get started. Once you have that and a .tale file, you have a playable story. Zip it up, and you can play it in an existing player. Don’t have an existing player? I offer a hosted player that has no server side component. It runs completely in your browser locally. Your files never leave your computer.

Let’s get nerdy for a bit. This is the technology part of the talk

Tech Stack

This is 100% built in C# from the ground up. You don’t need .NET to play. You don’t even need .NET to publish. If you can zip text files, you can make a game playable.

The engine is a collection of libraries that build on each other. The core is the RPG mechanics, state management, event log, deterministic dice, and all the things that get tricky when you’re writing them yourself. It is completely standalone

Talemark is a custom DSL built on top of the core runtime. It uses a hand-rolled, regex-free parser that breaks files into scene-isolated syntax trees, tokenizes expressions and prose cleanly, and passes them through a static binder to catch broken links, typos, and state bugs before the story ever runs.

The narrative and runtime layers turn the AST (abstract syntax tree) into a game. This produces a presentation agnostic document that can be read by a front-end (doesn’t have to be mine, but there’s a caveat). This keeps the language separate from the core which keeps the core and the language separate from the presentation layer. This becomes important 6 months from now.

Then there’s the other layers. I have a cross platform desktop and web app built entirely in Blazor with C#. Both applications are served by the same core. Blazor web assembly (WASM) powers the web version, and Photino powers that same Blazor natively on the desktop via built-in webviews. That means that your desktop version will almost always look and act the same as the web version. There is no electron. There is no heavy javascript framework. There are only assemblies running in webviews.

I use Photino for the desktop application, and it has been a joy to work with.

The authoring experience

I wrote this with authors in mind. I wrote this with the hope and dream that anyone could pick this up and write an interactive story. That’s why my first external author was my son. I wanted to see if the instructions were clear enough, the syntax simple enough, and the play-test loop easy enough for someone with no prior experience to succeed.

That has been and remains my number one goal. You should be able to author a story or a game without feeling like the tooling and framework is in the way. The framework should feel like it’s helping you tell the story, not fussing at you as you go.

That’s why I wrote a language server, a command-line interface (CLI), and a VS Code extension to help authors with the fiddly syntax bits. As your story grows, you shouldn’t have to ctrl+f to figure out what you called that scene. The editor should just tell you.

It’s your story, split it across as many files as you want. However you like to organize your work, Talewright will let you (there are limitations, obviously).

Players shouldn’t have to find the bugs. Talewright’s compiler and language server utilize static analysis and a graph of the story to find common mistakes. Syntax errors are surfaced immediately. Compilation fails if you typo an image. Dead-end scenes are discovered through the graph and surfaced as a warning. Unreachable scenes are also reported as a warning.

Talewright is able to do this in real-time because the language server uses the same compiler that the apps do. All roads lead through the compiler. This makes managing state, scenes, and complex logic simple.

Testing is also made easy with the CLI-bundled debugger. It offers a hot-reload, state-overrides, tracked playthroughs, a visualized map with conditions on connections, and it’s all built on the exact same presentation layer that a player will see when they actually play your game

Oh lawd, he’s still going

Where I’m at today: My docs say that I’m waiting for a v1 launch before I do a language freeze to ensure backward compatibility. The last thing that I want to do is introduce this, have someone actually try to write a story, and then immediately break it with an update. As of today, I have 0 language changes planned. I’ve been writing a story and fixing only what I consider “showstopper” bugs in the authoring experience

Save? Yep, they work. They’re pretty much always backward compatible no matter what you change in the story.

Replay? Back and forward? Got that too. The event log in the core ensures complete deterministic replay. This prevents save scumming to game rolls, and it means that players can always time travel back to that choice they regret. There is no hard cap on replay. Again, there’s a caveat on that, but we can nerd out about that later.

Full history without side effect? You betcha.

The entire application is written with accessibility in mind. The web and desktop players should work with assistive tech. Even the debugger and the visual map are built with accessibility in mind.

What’s it missing

Well, to be frank, quite a bit compared to a lot of the options. I won’t pretend I have what I don’t. I’ve focused on things that I think were painful. I’ve focused on building a strong base for the future, and I’ve decided that it’s time for me to stop writing this for myself and get feedback from the community. That’s where you all come in. It’s time for me to stop tinkering and see what feedback the community has.

The things that I know it’s missing are:

  1. Full UI customization - You can write your own CSS and bundle it. You can even write your own javascript if you want. I do not have great documentation on this, and it isn’t something I fully support
  2. Talemark customizations and effects - Right now, the font you get is the font you get. The colors you get are the colors you get. There’s not much in the way of presentation that you can do in Talemark. You can bold and italicize things. There’s some text-manipulators built in that help you with common agreement, capitalization, pluralization, and pronoun gotchas.
  3. Pronoun forms are… verbose - This is a carry-over from early in the project when I was still trying to settle the syntax. I know it’s a problem, and I have some ideas on how I can make this more palatable
  4. Sound - I don’t offer anything
  5. Videos - Not supported, yet
  6. Gifs - Not supported, but you can use animated .webp
  7. Arrays, lists, and loops - I’ve purposely kept this simple to see where the demand is
  8. Partials and fragments - You can’t write something and inject it wherever you want. You theoretically could with variables. That would be ugly, and the text won’t be parsed as Talemark
  9. Text-input - I don’t offer dropdowns, textboxes, or any other standard inputs. This is, again, by design to keep things simple until I know what folks want. There is a one time character creator that offers custom names, pronouns, classes, and minimal stat modifications. It needs a redesign.
  10. The things you’ll tell me - That’s why I’m doing this

Enough tell, more show

Fine, fine, fine. Here’s the links

Github - GitHub - squid-farm/talewright: Build and share branching text adventures and visual novels with Talewright—an open-source engine with its own story language, authoring and debugging tools, and web and desktop players. · GitHub

Marketing site - https://www.trytalewright.com/

Web player - https://play.trytalewright.com/

A sample story - Baked into the web player. Select “The Lost Relic”

A note about the illustrations and the baked in sample story - They’re AI generated. I’m not an illustrator. The story is AI generated and meant to be more of a tech demo, not a real story (see the source for the tech goodies - talewright/samples/LostRelic at main · squid-farm/talewright · GitHub )

Here’s a high level roadmap - https://github.com/squid-farm/talewright/blob/main/docs/roadmap.md

* See this post for my WIP game - Talewright - Yet another framework - #19 by squid-farm-actual

In addition to the roadmap, feel free to follow along with my issues, open your own, or even author a pull request. As a solo dev, this has been a daunting project - even with the chainsaw that is AI. I’d love to have collaborators on this project to bring in a different perspective

There is no AI in Talewright itself. The AI starts and stops at implementing the code I tell it to.

Wrap it up Joel

Talewright is designed for authors. It’s built to be simple. It’s built to stay simple. It’s built to make complex things look simple. It’s free. It’ll always be free. It’s MPL-2.0 licensed. That means you can do what you want with it. The bundled output is yours to do with as you please. The only restriction is that forks and code modifications must be kept open source.

It’s built to scale massively. It’s built to run fast. It’s built to give you a turn-key RPG system without the fiddly bits.

Another shout-out to the outstanding choices that are available to the authors. I cannot possibly over-emphasize how influential ChoiceScript, Ink, Twine, and Ren’py have been. Those systems show what a good narrative engine can and should be, and this project wouldn’t exist without them.

Last words, I promise

I’m looking for real feedback. I’m looking for folks who are willing to take a gamble and try to write something with yet another new system. I’m looking for experienced authors to help me sand down the rough edges and make this thing sing.

If you’re an author who uses assistive tech, I’d really love your help making sure that this stays accessible to all. I want this to be something anyone can pick up and publish a story with no matter who they are. I built this because I love art, and I wanted to build something that helps folks make art.

Talewright is ready, working, and sitting at v0.7.0-preview.1. With help from you all, this will be at v1 in no time.

If you made it to the end of this, thank you! If you check out Talewright and try it out, double thank you!

Edit: Added link to post containing the early demo of my game. Fixed a typo while I was at it

Parts of this look eerily familiar to me.

I was scrolling through this section earlier tonight and I saw Stage and Bardic for the first time. I almost let the big, ugly voice win and didn’t post because of the eerie similarities :sweat_smile:

Stage looks super cool. Love the config based concept. I wanted to split things between config and “plain” text so authors wouldn’t have to declare big ugly objects in the middle of prose.

Great minds think alike, or some such. Cheers and thanks for checking it out!

Fair enough, I appreciate triggers are a fairly common paradigm especially in interactive fiction, it’s just always a bit depressing when you see something so similar to something i’ve worked really hard on since 2020, particularly those core mechanics - that’s the piece that i’m ever so proud of, even if it doesn’t seem like that great an idea to others. Alas, there’s a lot of nice features in Talewright, and many of them I’ve been thinking about but I don’t really like AI just crunching away at night on functionality, I slave over little decisions (not to say you don’t).

I will continue working away on my engine but think i’ve started to realise that the landscape now just means that nothing is sacred or new under the sun. I hope this doesn’t feel like an attack on you, just more a frustration with the way things are now.

I’d quite enjoy working with someone to improve Stage, for example, to iron out the pieces that aren’t quite smooth.

I particularly like your testing system, allowing you to jump to a particular scene/location in the game so that you can test from there. I’ve got a world seed that allows me to do a little of that, but that’s a nice way to do it.

Why would anyone do that? What’s in it for us?

1 Like

I have a lot of those same feelings. I’ve been in the industry a long time, and the change that’s happened overnight feels like it’s cheapened the craft. I’m actually working on a post lamenting the same thing. AI is changing the world, for better or worse. I feel as if the overall impact is negative despite the positive impact it could have. It’s good to do hard things the hard way sometimes.

To be honest, there’s nothing in it for you except a shout-out in my hall of fame. If you’ve got an engine, language, system, and workflow that works for you, there’s absolutely no reason to try it, no matter how cool and fun I think it is.

I’m not trying to convince anyone to give up their favorites and write their next masterpiece with Talewright. I started writing this for myself for a specific idea in my head, thought, “Hey, this is pretty neat”, and began turning it into something that other people could use easily without writing a line of C#. I’ll continue to do that, but my secondary goal is much better achieved with the help of folks who have been doing this longer than me.

I’m a software developer with a writing hobby, and I’ve reached a point where I need that perspective to keep making the best decisions for Talewright. I’ll keep going with or without it.

Welcome to the site!

In my experience, “people who are comfortable using CLIs” is a subset of “people who are comfortable writing real code”. There are plenty of people on this forum who code exclusively via graphical IDEs but don’t shy away from close-to-the-metal systems like Inform 6.

I’m going to put this bluntly—if you don’t care enough about your tool to write an actual story in it, then nobody else is likely to, either.

This would make a better selling point than an AI-generated game. As long as it’s not full-on pornography, I’d suggest including it here behind a content warning. (If it is full-on pornography, we actually have a forum section for that as well; you just need to request access.)

3 Likes

Completely agree. That’s been one of my biggest concerns with the way I decided to go about this. Starting from .NET was already a poor choice given the need for an SDK. Putting things behind a CLI doubled down on the engineer brain.

The VS Code extension does offer help with that. However, I didn’t include the ability to publish a standalone game via the command palette. That is excellent feedback and something that I’ll start working on. I’ll also explore F5 options for publishing and playing. The setup tax is fairly daunting. talewright/docs/guide/getting-started.md at main · squid-farm/talewright · GitHub

More good, pointed feedback, and I concur. I wasn’t sure how it would get classified, so I opted not to include it.

I started by writing the early parts of the story coupled to the engine before I decided to pivot and focus on making the engine and language standalone. Story got pushed back, and I’ve been trying to make more progress on that than Talewright itself for the last week.

It is suggestive, but definitely not XXX. I’ll post that up when I’m back at my machine tonight. I appreciate you taking the time to look and provide constructive criticism.

1 Like

Hello.

Well done making your own system. It looks very good. Unfortunately, the sad truth is that it’s always a tough sell to get anyone to adopt something.

And that’s not because of any shortcomings or faults. From what ive seen, it looks quite good; you’ve made a demo which it shows the look and feel.

A lot of people announce their new systems and they’re all making the same mistake;

It’s not revolutionary.

That’s a tough pill to swallow because you can’t “just” make something revolutionary.

The existing systems have a pass because they were there first. And, back when they’re were new, they were revolutionary!

Your system looks like it’s a kind of “Ink++” with additional RPG elements. Although this might make writing a choice-based RPG easier, an author could probably build the same game in standard Ink, albeit with slightly more authorship work.

Since being revolutionary is like asking to win the lottery, what can we actually do?

A new direction for IF. Not just for your system, but for IF in general.

Some tangential observations:

The parser gave players the illusion of agency. Much of that is often lost with choice based narratives. What system features can be invented to help authors of choice based narratives give more player agency? How would that actually look?

Players like character interaction. What can be done to make story characters more player engaging, whilst minimising additional authorship? Most systems here, chuck in an LLM and hope for the best. So far, this approach hasn’t worked. What can be done in this space?

Deployment. And this is the thing that most new systems leave. What’s needed is “one button publishing”. export to web HTML, to windows EXE to Mac App, to an Android APK/AAB, iOS, Linux etc. And actually look like a game on mobile and not just a thinly wrapped web page.

Which brings me to my final point;

For traction, modern IF must actually look like a game, not a web page, a programming tool or a command line terminal. Games have bespoke, styled GUI, run in 16:9 and wider. Landscape on mobile. They have graphics and sound.

Modern IF games should look better in 16:9 (and wider) than they do in portrait, and use the whole screen on mobile.

So much space wasted here. It looks like a web page, not a game. The picture, which should be the main attractor, is too small and too dull. And the choices aren’t even all visible.

My 2c. Others have different opinions.

1 Like

Thank you :heart:

You’re spot on there. A lot of this is like trying to invent a better mouse trap. The existing systems have the staying power they do because it’s so hard to improve on something that does its job simply and well. There’s the Apple approach, which I think most the systems I’ve seen since joining intfiction trend toward - including mine. Make it prettier. Make it easier.

Whether that’s enough or not depends on the strength of the current defacto standards, and they’re all pretty darn strong, pretty darn supported, and have pretty robust communities around them.

I’m under no illusion that this gaining any sort of traction is a moonshot.

The LLM thing is not the solution. I’ve thought about that quite a bit. I’m not eager to include an LLM in human-to-human writing for a lot of reasons. I know this community and a lot of other artistic communities have very strong opinions about LLMs and AI in general. I share many of those opinions.

I’m very conflicted about AI as a whole. For my field, I treat it like a power tool. For art, that’s a much more ethically gray area, in my opinion. AI is good at a lot of things, but creativity is not one of them. It is a mish-mash of styles boiled down to the most beige interpretation of others’ work.

The irony and contradiction is not lost on me given my usage of AI generated art (as an aside: if there are any illustrators reading this, I’d love to work with someone to replace the art with legitimate, human art)

Innovation is arguably the hardest thing to do. It almost can’t be a goal because it ends up being forced. You raise a very good question: Is this just ink++? As it stands now, yes. More like ink± given I’m lacking a lot of what I consider “basic” features that ink has today.

I’m considering offering a parser extension to the system once I feel like I’ve nailed the basics of the choice-driven genre, but that, again, is probably not enough. I also haven’t given it enough thought to understand what that actually means for the engine. The narrative and runtime layers are more coupled to the engine than I want them to be right now, but that is where I’d start attempting to offer different input modes.

That is almost certainly not enough to give this the staying power the established systems have. That is, I believe, what Coral was poking at.

All those questions are something I need to chew on, and that is exactly the perspective I was hoping to gain from posting this. Thank you.

Agree again. As Draconis pointed out, hiding the publishing options behind a CLI is a poor choice. That’s something I can and will fix. The CLI does output all the desktop platforms at once. The web publish is separate, and, now that I’m talking about it, it feels rather clunky. That’s another authoring improvement that I can and should invest in. Mobile is something I wasn’t ready to tackle yet, but it’s definitely rattling around in my brain. talewright/docs/guide/sharing-your-story.md at main · squid-farm/talewright · GitHub

Since this runs in a webview, it should be a relatively simple wrapper job. Whether that satisfies the “not just a thinly wrapped web page” aspect comes down to how well I can design the UI. I’m not a UI guy. I’m a backend systems engineer, so that’s something that will continue to be a struggle for me.

Extremely good feedback. I do have options to adjust the width of the main column, but not enough to fill in all that space. Further, I should detect screen size and choose a width that fits most cleanly by default.

Some of this is by design. Some of it is due to my ignorance regarding what players and authors actually want. I purposely chose to keep the presentation layer simple and focus on making the core of the system as robust and extensible as possible. As I mentioned, I’m not a UI guy, so a lot of this doesn’t come naturally to me.

My early development stance was, “If authors want a highly customizable UI, they’ll probably use Ren’py”. I’ve made a lot of shortsighted decisions on this project, and that may well be one of them.

It doesn’t help anything right now, but a long term target of mine is to make a bridge for Godot and Unity. My UI is not well situated for authors to customize right now, and I know that’s a huge blind spot for me. It’s something that I’ve been considering and have in my backlog.

https://github.com/squid-farm/talewright/issues/660

As far as making it “gamier”, I chose to make the vanilla UI look very vanilla because I didn’t want to dictate what sort of things authors were going to make with this. I know what I wanted to make, and I know that I’m ok with a very plain UI. That does not mean that others are.

The picture feedback is gold, and it’s something that’s been bothering me. I kept putting it off until I got around to adding more Talemark driven styling, but your screenshot is pretty motivating.

Thank you so much for the thoughtful feedback. This is pure gold for a developer, and I really appreciate you taking the time to put this together. You’ve given me a lot to think about, and that makes me very happy :folded_hands:

I’m not sure what the selling points are here relative to Ink, aside from the built-in RPG mechanics. Kinda seems like a dedicated RPG template/library for Ink could have accomplished something similar, but with less reinventing the wheel?

1 Like

You aren’t wrong. It is heavily inspired by and, I hope, tastefully and respectfully nodding to a lot of the great ideas in Ink. This would not exist without Ink.

I’ll separate the two concepts: What are the selling points and why I chose not to build an RPG template or a library for ink

The main selling points, in my opinion, are the simplicity in getting started (aside from the excellent points from the previous comments), the state management, the extensibility of the RPG system, and the stability and event log of the engine. I make it sound so sexy, huh?

Out of the box, you can use advanced RPG mechanics. State management is safely handled for you. The syntax includes the basic things you need in order to do advanced things.

Some things are still clunky if you want to implement more advanced RPG type functionality. Combat, as an example, is very verbose in Talewright currently. I have built in combat planned for a future iteration.

The inventory system is functional. It works today. It’s simple to manage the inventory. Managing equipped items, usable items, and other, more advanced inventory management concepts is more difficult than it will be in the subsequent releases.

This is a very early preview still. It is stable, and I am planning on maintaining backward compatibility from now until v2 unless there are major, core, game-breaking issues discovered that force me to abandon that promise.

I have enough functionality to build stories, manage state, catch basic authoring mistakes, and bundle this up for web and desktop. I forced myself to post about this now rather than when I’d stacked it with all the features I wanted in order to discover what authors actually want.

The last thing I wanted to do was build a system stuffed with features no one would want or use. Every feature I add without external author feedback is a risk to longevity of the project.

As for why I didn’t just extend Ink, I have a lot of plans for what I want to do with this, and I wanted to own the language. I wanted to own the system from the ground up and not have a dependency on something I didn’t control.

Control freak? Maybe. Delusions of grandeur? Possibly. More ambition than sense? Definitely.

For what it’s worth, I disagree with jkj yuio on this one. I’m in the camp that believes lines longer than 50-75 characters get harder to read. So the Å-machine web interpreter also uses a maximum column width and won’t stretch its lines from edge to edge on a widescreen monitor.

3 Likes

I didn’t say there should be long lines! Just because you’re widescreen.

for example, be more creative with the text and picture placement:

.

2 Likes

That’s also my feeling. My current width setting doesn’t even approach fullscreen. This is very purposefully designed as a text first system.

That’s a fantastic example. This is where I’d expect folks to use Ren’py or something that’s built more with custom UI in mind. It’s not something that that’s a high priority for me now, and maybe not ever. The Unity + Godot bridges are probably where I’d push something like this.

Talewright powers the state, narrative, and RPG mechanics; Godot or Unity powers the presentation layer.

I’m having to be very choosy about what I implement and when :slight_smile:

Edit: One thing that I don’t think I’m tracking on my backlog yet, but will definitely help with widescreen implementation is background images. That’s probably about as far as I’ll take this before I start supporting full author/dev driven UI overhauls

1 Like

That’s just you making Visual Novels, instead of Interactive Fiction (or text games, if you prefer).

There’s nothing wrong with that, but it’s a different style of game with a different preference.

Honestly, i find that a bit insulting, “instead of Interactive Fiction”. VNs never have long form text. They put a only a few words at a time on screen. My work is more a graphical IF. But it is definitely IF!

1 Like

I didn’t mean to be insulting. I don’t even play VNs, so I don’t know where the borders of a VN end. Your game looks great, but I don’t know if my first impression would be “text game”.

What I’m disputing is that all IF must look like this, or they aren’t worth producing in the modern era — which was kind of how I read your comment.

That looks super cool. Love the atmosphere.

Alright folks. Here’s the game that I’ve been working on. I had a mad dash to fix the desktop publishes.

For the playable web version, there’s a brief flash saying that you need to retry the load. It reloads itself, but it’s not the best look. I’m not sure if this is an itch specific behavior or if it’s something with this story. I will investigate and get it fixed either way.

In addition to the web build, I have added variants for Mac, Linux, and Windows.

The game is very short. It’s mostly world-building at this point. I’ve been authoring the history and political landscape on Earth in my notes primarily. I’ve incorporated some of that into what we’ll generously call a playable demo. There is AI artwork involved.

Eventually, we will go to another galaxy and encounter wonders and horrors alike.

Content Warning (18+ / Mature Themes): Contains strong language, moderate violence, smoking/tobacco use, suggestive themes, and stylized pin-up artwork (revealing outfits and swimwear, no explicit nudity or sexual acts).