u/Michael_Voitovich

I had always wanted a modern Windows terminal that emulated a CRT monitor—something like Cool Retro Term for Linux. However, nothing of the sort existed for Windows, aside from a rather pathetic attempt at simulating scanlines in Microsoft Terminal. Even when Cool-Retro was eventually ported to Windows, the quality of the effects in the port seemed inferior to the Linux version.

At the time, I was developing a game and its custom engine -- featuring a highly realistic, deeply customizable CRT simulation (inspired by Cool-Retro) -- because the game was about hackers and geeks in 1980s, requiring interaction with a wide variety of computers and terminals. Then it hit me: I could take that shader from the game, combine it with the native Windows ConPTY, and easily create a Cool Retro Term equivalent -- one that was even more realistic and customizable, and ran natively on Windows. The first prototype was ready in just a couple of days, and it worked beautifully! Of course, it required a lot of polishing, and I also wanted to implement several other useful features, such as:

• Multi-tab support with individual style settings.
• Console buffer search, quick text copying via the middle mouse button, etc.
• Smooth, pixel-perfect vertical scrolling- both in the shell and in applications like Vim.
• A built-in mini web browser optimized for keyboard control. Useful for keeping documentation or a web service right inside the terminal.
• A mode for viewing all terminal sessions as thumbnails - "Win-Tab" style.
• A GUI settings panel (you can also just simply edit the JSON config).
• The ability to open new tabs with specific CRT-theme directly from the command line.
• A toggleable AI assistant panel based on Codex that can interact with the console on your behalf or collaborate with you.

Regarding that last feature -- I realize people often look askance at apps that integrate with generative LLMs. But let’s be honest: these days, AI is being shoehorned into almost every piece of software, whether it makes sense or not. But in this specific case, it is more than justified. I believe it’s incredibly useful to be able to ask the AI in plain English to turn a request into a PowerShell command, help configure Vim, construct a complex SQL query, and so on, right within the terminal. The key advantage here is that you see everything it writes to the console, allowing you to learn new commands and tricks. It embodies the IBM principle: the machine should do the work, while the human makes the decisions. And if you’re an expert, you can simply disable the panel.

I’ll admit it: Scanline Term itself was created with some AI assistance. It wasn't exactly "vibe coding," but rather agent-based development where I handled the architecture and high-level functions, while the AI ​​did the grunt work. Nevertheless, it is a native, polished, and compact application -- clocking in at around 19 MB, it launches instantly, is memory-efficient, and runs fast.

By the way, the CRT simulation has a strange psychological effect - at least for me. It boosts concentration and focus on the text. When it’s running in full-screen mode, glowing and "breathing" with that analog feel, it somehow draws me in and helps me concentrate. While I used to work in the console only sporadically, now I actually want to jump in and immerse myself in that cozy phosphor glow -- just me and the code, the text, or a technical process. I experience something similar with vintage tube amplifiers and speakers; their unique sound draws me in and shuts out the outside world - a world that has hooked us all on quick dopamine hits.

In any case, this product turned out to be unexpectedly useful to me. I’d be happy if it proves helpful to others, too, and I’m always grateful for any feedback.

https://github.com/z-hunter/Scanline-Term

Hi! I'm developing Scanline, an open-source 2.5D adventure game engine inspired by Sierra and LucasArts games from the 1980s. Despite its retro look, it uses cutting-edge technology underneath the hood.

The engine combines point-and-click navigation with a natural-language text parser, but recently I’ve been working on a different problem: LLM NPCs that can do more than generate dialogue.

The difficult part wasn’t making an LLM speak in character. It was letting the model interact with the game world without allowing it to invent state, bypass game rules, or get stuck burning tokens in loops.

My current solution is a system called the Puppet Master.

Each NPC has its own objectives, persistent memory, inventory, perception, and knowledge of the world. The Puppet Master receives both authored scene information and the NPC’s current runtime context, then returns a structured JSON plan rather than unrestricted commands.

A plan may contain steps such as:

• SAY
• MOVE_TO
• LOOK or EXAMINE
• OPEN or CLOSE
• TAKE or PUT
• USE an item
• WAIT
• update memory or objectives

The LLM only proposes the plan. The engine validates and executes every step through the same semantic action system used by the player. This means an NPC cannot take an unreachable object, open a locked container without satisfying its requirements, or claim to have found a hidden item unless the runtime confirms the discovery.

Multi-step plans can continue after movement or other asynchronous actions without another LLM request. They can also be interrupted when an item is found, the world changes, or an action fails.

I also added batching, rate limits, repeated-action detection, pattern-loop detection, and a filter for unsupported discovery claims. These safeguards turned out to be at least as important as the prompts themselves.

I recorded a video showing the system in action and explaining the architecture:

https://youtu.be/PTmhnVVa4Sk (sorry for the auto-generated English translation)

The engine and NPC implementation are available here:

https://github.com/z-hunter/Quest/