TIGSource Forums

UPDATE (15 April 2017) - version 1.3 adds an integrated debugger: here (https://forums.tigsource.com/index.php?topic=48505.msg1329400#msg1329400).

UPDATE (31 March 2017) - time for version 1.2! See here (https://forums.tigsource.com/index.php?topic=48505.msg1326059#msg1326059).

UPDATE (11 March 2017) - version 1.0 is up! See here (https://forums.tigsource.com/index.php?topic=48505.msg1321812#msg1321812).

UPDATE (3 March 2017) - A new beta release! See this post (https://forums.tigsource.com/index.php?topic=48505.msg1320018#msg1320018).

UPDATE (17 February 2017) - A beta release! And a trailer! The post. (https://forums.tigsource.com/index.php?topic=48505.msg1316886#msg1316886)

UPDATE (4 August 2016) - I've uploaded a new release. Here's the post (https://forums.tigsource.com/index.php?topic=48505.msg1269740#msg1269740).

UPDATE (5 July 2016) - I've uploaded a work-in-progress release and a video. See this post (https://forums.tigsource.com/index.php?topic=48505.msg1261863#msg1261863).

(http://i.imgur.com/llTlwkK.png)

https://www.youtube.com/watch?v=1i6DHUiJd44 (https://www.youtube.com/watch?v=1i6DHUiJd44)

...

Liberation Circuit is a real-time strategy game about processes battling for control of a computer system. At this stage of development it looks like this:

(http://i203.photobucket.com/albums/aa149/coloured_lights/LC_ss6.png)

and this:

(http://i203.photobucket.com/albums/aa149/coloured_lights/LC_ss7.png)

As well as being a unit in the RTS each process is also an actual program, written in a (very) simplified version of C and running as bytecode in a simple virtual machine. The game has a graphical process designer that lets you design processes by putting them together, piece by piece, and then automatically generates code to run the processes you design. But if you want to fine-tune your units you can use the game's built-in code editor and compiler to change the way they respond to your commands or give them completely autonomous AI.

So it's basically an RTS that you can also play as a programming game.

Liberation Circuit is based on my previous project Invincible Countermeasure (http://forums.tigsource.com/index.php?topic=42831.0):

(http://i203.photobucket.com/albums/aa149/coloured_lights/spider_sm.png)

IC was a fascinating development project but unfortunately didn't really work as a game - the RTS part was too drifty and slow and the programming part was impossibly complicated. LC should fix both of those problems: the action will be much faster and more exciting (and at 60fps instead of 30) and the API is vastly simpler and easier to use (as well as being optional if you want to use the designer instead of hand-coding everything).

It will be released under the GPL and since it uses Allegro it will run on various platforms (at least Windows, Linux and Mac).

Progress: the basic game engine, bytecode interpreter, compiler, process designer, and code editor are working, although they'll all get some more polish. You can put together a process in the designer, auto-generate code to run it, compile the code, create the process in the game-world then tell it to move around and attack another process.

Still to do:
- adding more "objects" (the bits attached to processes that let them do things, like move and attack)
- visual effects like explosions (the effects in Invincible Countermeasure left plenty of scope for improvement)
- sound effects and music. If I have time I'd like to write my own software synth
- better backgrounds
- some kind of multiplayer
- many other things!

I'll also try to keep this devlog up to date...

Some progress:

(http://i203.photobucket.com/albums/aa149/coloured_lights/LC_ss5.png)

The graphics have been overhauled and everything looks much better now. The game is in an almost playable state (although far from finished), and fixing up the user interface is my next job. The unit AI generator is working properly now and produces AI capable of accepting various commands and doing a few things by itself, like acquiring targets for defensive weapons and aiming them, but things like selection and target indicator graphics need work. More soon!

I was originally going to let the player see the entire map and everything going on in the game, but now I'm thinking that some kind of fog of war might make the game more interesting - scouting and information-gathering will become important and you never know exactly what's going on.

The obvious way to implement it is to prepare a display-sized bitmap filled with solid black, then cut holes in it around each unit with some alpha blending around the edges, then blit it over the display like so:

(http://i203.photobucket.com/albums/aa149/coloured_lights/LC_ss7.png)

The map down the bottom right works in a similar way.

I thought this would slow things down a lot, but even with lots of things on a zoomed-out screen it doesn't make a huge difference to the framerate. Nice!

The problem with doing fog of war like this is that it doesn't give a direct way to work out whether any particular enemy unit is visible, e.g. if you click on it. I'll probably deal with this by splitting the map into blocks then, each tick/frame, updating the blocks in a circle around each unit with a timestamp indicating that anything in the block is currently visible.

looks and sounds pretty cool. will this be Player vs AI only or also Player vs Player?
I'm currently looking into networking myself and some things can be a real pain :I, was just wondering how this could work with custom unit code.

Thanks!

The RTS part of the game (where the player designs and directly controls the units) will just be Player vs AI, at least at first.

The pure coding part of the game (where the player designs units and gives them AI, but doesn't control them directly after the game starts) will be both Player vs AI and Player vs Player - PvP will involve loading your units and someone else's units into a game and seeing who wins.

It should be possible to network the RTS part as well, but the last networked game I wrote used libnet to play over serial cable in DOS and I don't really have the skills to do the same kind of thing with modern technology...

I love foss games and adore games with programming in them. Looking forward to trying this!

I like the polygon aesthetics and the code-based gameplay sounds very interesting. I'd consider to make the Fog-of-war by fading the background polys to black. That fuzzy black overlay looks off.

Could you post a screenshot where the code is readable? Can you script only the behavior but also the form and capabilites of ships?

Yeah, I was thinking of something like that but the fuzzy overlay thing was easier to implement. I might try a few other approaches and see how they look.


Here's a screenshot of the unit designer and the code editor, with a basic process loaded in:

(http://i203.photobucket.com/albums/aa149/coloured_lights/LC_ss8a.png)

Unit form and capability is coded in the header between the #process and #code lines, and you can design anything you like within the game's rules about cost, weight, maximum number of components etc. The header can be hand-edited, but it's much easier to use the designer and get it to automatically generate the header for you.

The rest of the code is most of the AI for a simple unit that wanders randomly around the map looking for something to attack.

(edit: I should mention that you can play without touching a line of code - the game can generate it for you based on the unit design)


It's *almost* playable!

Okay, here's another shot at the fog of war effect. Instead of an alpha blend, the hidden part breaks up as a unit approaches and reforms as the unit leaves. The visible area is square, which reflects the way units see the world:

(http://i.imgur.com/UaEu9W6.gif)

that api looks straight forward enough to not scare me away :) there are not enough good coding games.^^

I like the new shot at the fog of war a lot better. I'm sure you could leave it that way but if I were asked to implement this (no time constraints and all) I'd probably experiment with animated voronoi. have a a bunch of swirly swarming particles to form the base of a fullscreen voronoi diagram (https://www.youtube.com/watch?v=2oYMJVsK3aM) for all particles outside the radius where the fading happens the resulting shapes are all black, inside they are all transparent and between they fade basedon the center position... if you won't try it I might have to hack something together because in my head this looks way cool. =)

the fog of war looks cool, nice idea. makes it look more abstract/technical, that suits your project very well.

do you have any debugging aids for the player? my own project used to be a code-game too, I just added simple text-output and basic shapes that overlay the view. now its a racing game, but I still have the editor stuff  ::) and plan to get back to it some time.

I love the look of voronoi patterns (I didn't know what these were called before - thanks!) but I think even the optimised algorithms to generate them will be too complex and expensive to use them as animations. However, I'm experimenting with improvements that should allow non-rectangular bits of shadow without the smooth horizontal and vertical lines in the version I posted, and this might make voronoi-like patterns with fixed points/borders possible.


Processes can use printf() to send formatted text to a console on the display, and there'll be a verbose-error mode which will automatically inform the player of execution errors like out-of-bounds memory access (all memory access by in-game programs is rigorously bounds-checked, so these should always be caught), or specific errors in calls to built-in functions/methods. These error messages will probably mention which line of the source code the error occurred on.

Eventually there'll also be a way to generate a readable asm-like representation of the bytecode that the compiler produces, as well as an inline assembler and (maybe) dissassembler.

Other than that, I'm not sure - I'm not very familiar with other kinds of debugging tools, and writing decent user interfaces for things like that is really hard!


What kind of code did it use? I've been looking for a good programming game ever since I tried to work out PCRobots in DOS many years ago, but haven't had much luck (thus this project).

I made something like a programming game a while ago: http://forums.tigsource.com/index.php?topic=37355.0

Also your's reminded me of http://tpoindex.github.io/crobots/ because it uses a C like language too but of course its 30 years old just like the classics https://en.wikipedia.org/wiki/RobotWar and https://en.wikipedia.org/wiki/Core_War
I don't know any supercool contemporary programming games if those exist.

Core War thread: http://forums.tigsource.com/index.php?topic=9432.0

I tried playing robocode (http://robocode.sourceforge.net/) a bit, but the best robots were too good and I didn't have any friends to compete with.

The modern master is Zachtronics (https://en.wikipedia.org/wiki/Zachary_Barth). Most of his games are sort of engineering/programming hybrids. Like SpaceChem (https://en.wikipedia.org/wiki/SpaceChem) and InfiniFactory (http://www.zachtronics.com/infinifactory).

But currently I'm playing and loving his ASM puzzle game TIS-100 (https://en.wikipedia.org/wiki/TIS-100):

(http://i.stack.imgur.com/n0x5P.png) (http://i.stack.imgur.com/n0x5P.png)

it uses javascript, the whole project does, to be exact. you can find it in my signature :) but the programming part is currently on hold, the current tool is just used by me when I make AI. the current AI is struggling with new features, so I might have to make some adaptations.

TIS-100 is great fun! So much that I got the 100% achievement^^ Spacechem too. But those are more like puzzle games and not about scripting agents like Liberation Circuit seems to be.

Programming games are always such a joy.

Just looking, this reminds me of Battleships Forever (and Warning Forever, Captain Forever, etc). The component-based spaceships were a blast there, and no doubt here too; It may be worth a gander. The idea of being able to code completely AI-controlled ships is intriguing and could go a long way towards combating some of the problems BF ran into when you had too many units.

Good luck!

Yep, I love the visual style of Warning Forever! The structure of a process in this game (a core with trees of linked components, each with weapons etc attached to points around the edge) is similar to the structure of a WF boss as well.

I've been meaning to try TIS-100 as well. Looks like it's on GOG, so I have no excuse...


Yes.

I always liked the idea of Core Wars, but its hardcore asm-like nature kept me away (although I had to learn some of the basic ideas behind asm to write a compiler for this game, so I should probably try it sometime). I did look at a few of the agent-combat-based games like PCRobots, Robocode etc as well, but while the concept was fascinating in theory, in practice I didn't find the focus on maximising the performance of a single robot or whatever against other identical robots all that interesting.

Since I started working on this game new kinds of programming games have come out, like Code Combat and Else Heart.Break(). But I don't think there's anything else quite like Liberation Circuit yet.

Okay, third try at the fog of war effect:

(http://imgur.com/EIT0buc.png)

This one's my favourite so far.

looks cool, matches better to the background than the last version. although I liked the old one too. If you make two different races, maybe you could also use both fow types :)

the pentagonal selection looks nice too!

Cool ship designs!

Very very nice! :)

Well, development has been ticking along slowly but kind of steadily. Here's an update:

(http://i.imgur.com/NJuQ5G3.png)
This is a harvester process gathering data from a data well. You can see its movement objects at the back, its harvest object at the front, and one data storage object on each side. The yellow centre of the data well indicates how much data is presently available, and the orange things around it indicate its reserves (from which the available data will be replenished gradually).

Data is the basic currency of the game's economy; you need to gather it from data wells and bring it back to a process with an allocation object, which makes the data available to build new processes. Or you could use a builder process to build an allocator process near the data well (an allocator process is immobile).

(http://i.imgur.com/ZVE0jLj.png)

A process with long-range attack objects engages an immobile defensive process. The attacker has front-facing move objects which allow it to move backwards to keep its distance, although if it loses sight of its target it will probably stop firing unless it has a spotter (all processes on the same side share vision, with some limitations) or is configured to keep firing blindly.


(http://i.imgur.com/tHbuz2w.png)

A couple of larger processes face off. Each is partly protected by an interface (aka a shield) which can absorb a large amount of damage, but once it goes down the process can be destroyed component by component.

I'm loving the visuals and the theme of this. Looking forward to seeing this progress further!

So progress has been steady but slow...

(http://i.imgur.com/4LCUfCF.png)

These are autonomous (i.e. not user-controlled) processes - the large yellow one is a kind of leader which broadcasts a signal to other nearby processes, and the little yellow ones are followers that listen for the signal and, once they find it, swirl around the source. The blue process had some followers too, but they didn't make it :(

I've changed the fog of war effect again. I liked the look of the one I had before (the animated gif up the page) but the overall effect was kind of oppressive, as if there were always dark clouds rolling across the screen and closing over the player's vision. Also changed are the packet (bullet) and move object (engine) effects - now they look kind of like waves rippling along, instead of like more chunks of flat-shaded pixels.

And I just realised a few days ago that one of the fixed-point maths functions I was using (hypot) was secretly calling a floating-point function and converting the result back into fixed point. That's not good, because if I want the game to run consistently across as many different systems as possible I can't use any floating-point stuff in the gameplay code (there's plenty in the display code, though). Fortunately it turned out to be easier than expected to implement an integer-based sqrt, and not much slower.

Now I'm working on the manual. I know no-one reads manuals anymore, but this game really needs a readable specification for the programming API. It turns out that technical writing is not that easy!

This looks just great.  Cool concepts & art.  Will follow!

Sorry for the lack of updates, but it's difficult to make an interesting story out of things like "I fixed a bug in the expression parser" or "now the manual has a few pictures in it".

Anyway, time for a work-in-progress release! Version alpha 1 is now up at Sourceforge:

Windows binary (https://sourceforge.net/projects/liberation-circuit/files/alpha_1/LibCirc_alpha1_win.zip/download) (run LibCirc.exe to play; all data files and the manual are included in the zip)
Source code (https://sourceforge.net/projects/liberation-circuit/files/alpha_1/LibCirc_alpha1_src.zip/download) (requires the Allegro 5 library; should compile on any platform supported by Allegro)

Here's a few minutes of gameplay: https://www.youtube.com/watch?v=1i6DHUiJd44 (https://www.youtube.com/watch?v=1i6DHUiJd44)

The game is set up to run in a window, in case trying to run in fullscreen is a problem for some people. I suggest editing init.txt to make it run in fullscreen windowed mode if possible.

In this version:

• the basic gameplay is all there
• the autocoder generates all the code you need to play it like an RTS without doing any programming (the blue processes in the video are all autocoded)
• there are 7 increasingly difficult missions to play, including a tutorial
• asynchronous multiplayer is in
• there's a (mostly complete) description of the API in the manual

Still to come:

• rebalancing
• new components and objects
• story mode
• compiler optimisations
• lots of other stuff

Have fun. All comments/critique appreciated!

If anyone is interested in building their own Linux version, bamccaig at the allegro.cc forum has written a bash script to download and build the game (requires Allegro 5, of course). Here it is (https://www.allegro.cc/forums/thread/616382/1023749#target).

As he points out, Sourceforge has been getting itself a not-great reputation in the last few years. Does anyone know of any good alternatives (for FOSS projects) that are suitable for distributing binaries as well as source? Github seems to be focussed on collaboration through git and isn't really what I need. Maybe Fosshub (http://code.fosshub.com/)?

Anyway, I'm not sure about the font I used for most of the in-game text; the individual letters look okay, but it's hard to read somehow (part of the problem is that it needs to be fixed-width for various reasons). I'm thinking of going back to an older font with more rounded letters:

(http://i.imgur.com/g4nWtVo.png)

(example text from the tutorial mission: the current font is on the top; the new, rounded font is on the bottom).

Yeah, I think the rounded one is the way to go.

I had a problem with coordinating units building other units: if there were (say) 3 builders, with 2 of them trying to build multiple cheap units and 1 trying to build an expensive unit, the cheap units would use up all of the resources (data) as fast as they could be accumulated and the expensive unit would never get built.

This would be easy to fix if units had a single command program that could allocate building tasks in a unified way, but not so easy for LC's distributed unit AI. In the alpha release I dealt with it (for the enemy mission AI) by having the builder that was trying to make the expensive unit send out a broadcast asking other builders to stop building anything until the expensive unit was finished. But this was awkward and complicated.

Anyway, my solution was to add a unified build queue for each player, including computer-controlled players. Builder units can add build orders to it, and when one of a builder's orders is at the front of the queue it can execute it with a simple build_from_queue() call. Build commands given by the user through the mouse interface automatically go on the queue (and the user can also cancel orders on the queue or move them up and down). It seems to work!

(http://i.imgur.com/qTQXp31.png)

Some progress towards a beta release:

• A clearer and more useful tutorial
• Various improvements in the autocoded AI - in particular, it's less likely to collide with the enemy now
• Less bouncy collision physics
• A less cluttered interface - the process information box can be minimised now, and the console is smaller
• Fewer annoying method failure messages for things like trying to build with insufficient data
• The procedural music now starts off simple, then builds in complexity. It also has several more possible scales
• The build queue and font improvements mentioned above
• Better graphics for harvesting, transferring and repairing
• Support for non-QWERTY keyboards and key remapping
• Notifications when your units come under attack
• Follow mode, in which the display tracks the selected process
• Rebalancing and other minor changes - I think the stream method (the beam thing) is still a bit too good

I still need to do more testing, and update the manual with some of the API changes related to the build queue. I'm also thinking about adding a special chaos mission where the data well placement and the enemy's units are randomised to some extent, which could be interesting. Story mode will have to wait for something closer to the final release!

Time for a new release version! Alpha 2 is up at sourceforce:

Windows executable (https://sourceforge.net/projects/liberation-circuit/files/alpha_2/LibCirc_alpha2_win.zip/download)
Source code (https://sourceforge.net/projects/liberation-circuit/files/alpha_2/LibCirc_alpha2_src.zip/download)
Version page (https://sourceforge.net/projects/liberation-circuit/files/alpha_2/)

In this version:

• Many interface improvements
• A more comprehensive tutorial
• Some AI updates
• Some bug fixes (including an annoying memory leak)
• Lots of other things

This version opens to a fullscreen window by default, so if that will annoy you please edit init.txt before running it (see instructions in the text file).

This video shows the gameplay in more detail, including designing a new process and using the code editor (at the start I copy the code from the tri_base process into template 0, so that the more expensive tri_base process spawns at the beginning).

https://www.youtube.com/watch?v=5XCyQk_F7hA (https://www.youtube.com/watch?v=5XCyQk_F7hA)

Just added control groups - just like Starcraft 2, you can set a control group by pressing ctrl and a number (1-9) while some processes are selected, add to a control group by pressing shift and a number, and select a control group by pressing just the number (pressing it twice centres the display on the first member of the group).

This stuff is hard. I think the next game I write is going to have a very simple user interface...

I'm working on the backgrounds, which have up until now just been tiled hexagons with slightly randomised sizes (although they can be altered to some extent by events in the game). Latest addition: a fairly subtle parallax scrolling effect:

(http://i.imgur.com/k1uJou7.gif)

git & github/bitbucket do have collaboration features, but that's true for all version control systems. I'm pretty sure distributed version control systems (like git and mercurial) are the best option when working on your own, since you don't have to have a server if you don't want to. The project folder becomes it's own self-hosted repository. Hosting a copy on a server (like github) is completely optional and doesn't get in the way of your own work (just git/hg push your changes to the server if/when you want to) :)

for binaries github has "Releases" (https://help.github.com/articles/about-releases/ (https://help.github.com/articles/about-releases/)) and bitbucket has a standard download page

I've finally finished something I've been meaning to do for too long - adding drag-and-drop mouse controls to the process designer. I've also improved the selection indicator graphics, which were not very good; now they look like this:


(http://i.imgur.com/OxY9d5C.png)


You can drag an object (like the forward pulse object selected here) to move it to any other position on the process, and press shift to copy instead of moving. Objects and components are now rotated by dragging a rotation icon (the red thing with arrows) around instead of holding shift, which was kind of awkward in practice. Components can be moved around in a similar way, by clicking on the links connecting them together and dragging to another position (although copying components is not implemented at the moment). It's much better!

Okay, I've *finally* put it up on github :). The version there is very much a work-in-progress, but here it is:

https://github.com/linleyh/liberation-circuit (https://github.com/linleyh/liberation-circuit)

Almost there! All I have left to do is finish writing the AI for the last few missions, and a bit of testing. Plus fixing any problems I find along the way, which is of course the part that takes the most time.

A couple of screenshots, which show the new, improved explosions, the more detailed backgrounds and a number of other changes. More to come!

(http://i.imgur.com/MN8evam.png)

(http://i.imgur.com/QKWzkqA.png)

I think it's finished!

(http://i.imgur.com/pPIJ03I.png)

But it probably needs a little bit of testing, so I've called this a beta release. Here's the Windows binary:

https://github.com/linleyh/liberation-circuit/releases/tag/beta (https://github.com/linleyh/liberation-circuit/releases/tag/beta)

(to play, download LibCirc_v0.99_beta.zip and unzip, then run LibCirc.exe)

Here's the general github page for the game:

https://github.com/linleyh/liberation-circuit (https://github.com/linleyh/liberation-circuit)

And I've put a trailer up on Youtube:

https://www.youtube.com/watch?v=wLpyuTKCbbw (https://www.youtube.com/watch?v=wLpyuTKCbbw)

I'd really appreciate any feedback on this version. Have fun!

And a new beta release is up! It has a number of fixes and improvements, not least to the interface. Many thanks to zugz, who has given lots of useful feedback on the playtesting thread at https://forums.tigsource.com/index.php?topic=59890.0 (https://forums.tigsource.com/index.php?topic=59890.0).

Here's the release page on Github:

https://github.com/linleyh/liberation-circuit/releases/tag/v0.99B-beta3 (https://github.com/linleyh/liberation-circuit/releases/tag/v0.99B-beta3)

Windows users: download LibCirc_beta3_win.zip and run LibCirc.exe to play.

Everyone else: you'll need the data files in LibCirc_beta3_data.zip; the executable needs to be in the main directory (the same directory as readme.txt).

Have fun!

https://www.youtube.com/watch?v=Ky0ekTamk9Y (https://www.youtube.com/watch?v=Ky0ekTamk9Y)

A new video with plenty of RTS gameplay, playing a mission from the start: harvesting, expanding, defending, and designing new processes and sending them into battle.

The flexibility of your units designer is awesome! What are you using under the hood? Tons of subclasses?

Even better - thousands of lines of procedural C! And lots of recursion.

(http://i.imgur.com/3xx62oq.png)

It's taken a long time and many tens of thousands of lines of code, but the full release version of Liberation Circuit is finally ready:

Here it is. (https://github.com/linleyh/liberation-circuit/releases/latest) For the Windows binary, download Libcirc-v1.0-win-binary.zip and extract to a convenient location.

For other systems (Linux etc) there are compilation instructions in the readme.

To re-summarise: it's an RTS about escaping from a hostile computer system. It's also a programming game, and as well as controlling your units directly, you can also (optionally!) write your own AI routines for them.

Here's the trailer:

https://www.youtube.com/watch?v=wLpyuTKCbbw (https://www.youtube.com/watch?v=wLpyuTKCbbw)

And for more gameplay:

https://www.youtube.com/watch?v=Ky0ekTamk9Y (https://www.youtube.com/watch?v=Ky0ekTamk9Y)

Have fun!

Awesome job and congratulations for finishing the game! Only tried it a bit and it seems very polished. Will have to try it out more later.

Thanks!

I should mention that it's up on itch.io: https://linleyh.itch.io/liberation-circuit (https://linleyh.itch.io/liberation-circuit)

And a new version (1.2) is up:

on itch: https://linleyh.itch.io/liberation-circuit (https://linleyh.itch.io/liberation-circuit)
and Github: https://github.com/linleyh/liberation-circuit/releases/latest (https://github.com/linleyh/liberation-circuit/releases/latest)

Numerous changes, including:

• a new font size option (see init.txt)
• you can now use init.txt to specify a file to save mission progress to (in case your game directory is write-protected)
• "template files" have been renamed to "multi-binary files" to reflect their purpose as collections of multiple processes in binary format for use in multiplayer games
• many small changes to in-game text, to make it more helpful
• press space to cycle between active "under attack" alerts
• data well locations are marked on areas obscured by fog of war
• music is paused when the "exit game" box is displayed
• a new "quit game" option on the "exit game" box (quits to the story screen or the main menu)
• many other minor changes.

   

A new release!

Version 1.3 adds an integrated debugger/bytecode-watch system to help debug process code. v1.3 also fixes a few minor issues with v1.2.

Here's what the debugger looks like in action:

(http://i.imgur.com/8KK0FSV.png)

Edit: it would help if I posted the link. Here:
https://linleyh.itch.io/liberation-circuit (https://linleyh.itch.io/liberation-circuit)
https://github.com/linleyh/liberation-circuit/releases/latest (https://github.com/linleyh/liberation-circuit/releases/latest)