A quantum physics experiment puzzle (designed with Google's CP-SAT solver)
A quantum physics effect to teach, a puzzle to build, a problem to solve, a tool to learn!
Polarizing filters are plastic films that let light shine through only in a particular direction (angle). Combining two at 90 degrees completely blocks light.
Very counterintuitively, inserting a third filter between two filters at 90 degrees allows some light shine through!
This interesting effect can only be explained with quantum physics, as brilliantly explained in this 3Blue1Brown video.
Polarizing filter films are cheap... So I wanted to create a carboard toy to demo this effect in a suprising way to my kids!
A puzzle to build
Idea is to build a puzzle around this weird effect.
I want to build a cardboard octagon with many "windows" (holes), each window covered with one polarizing filter at a certain angle, like this:
Stacking multiple such octagons on top of one another will block light in some combination of filters and not others, depending on the individual filter angles. Moreover, rotating octagons in the stack will make the "displayed pattern" change!
A problem to solve
One a set of "patterns" to display is decided, is it possible to write a program to determine the assignment of filter angles, for each "window" in each octagon, that is able to produce them all?
In principle, yes! In practice, there's an explosion in the number of possible combinations! Eg. 8 angles × 10 windows × 8 slices × 5 octagons × 8⁴ rotation combinations × 5! orderings × 5 upside-down flips is about 8 billion.
...a bit too much for simple for loops! I need a smarter approach.
A tool to learn
Google OR-Tools CP-SAT is a powerful constraint programming solver. It can be used to quickly find solutions to huge combinatorial problems - where one has to find one valid assignment to thousands of variables under thousands of constraints within billions of possible combinations (not all of which valid or optimal)!
Solvers are applicable to many problems and are not new in SUSE's tradition - eg. the zypper package manager uses libsolv to compute valid package dependency combinations, and Uyuni uses Optaplanner to compute valid subscription assignments.
CP-SAT is open source, very efficient (actually close to the state of the art in the field) and easily scriptable from Python... a very interesting target to experiment with!
Now I have an excuse to play with this!
Scope of HackWeek
Find a combination that works for a decent example, and actually cut it in cardboard and filters to try it out!
https://github.com/moio/octaopticon
This project is part of:
Hack Week 23
Activity
Comments
-
about 2 years ago by moio | Reply
Day 1 diary - the physical prototyping day
Spent a bit of time into producing good SVGs with Python, then printed them and tried to find dimensions that worked (one big and one small for testing).
After few iterations decided to go with octagonal stars rather than plain octagons:
Then literally hammered out holes with a 10mm punch! Worked beautifully.
Then, cut and tested positioning of filter film:
All seems good from the physical realm so far.
Next up: coding to determine per-hole filter positioning!
-
about 2 years ago by moio | Reply
Day 2 diary: mostly coding
CP-SAT
Learnt a lot about CP-SAT, evolved some code I had around to handle:
- a variable number of "pizzas" ("stars with filter windows")
- a variable number of "slices" ("sectors" of stars)
- a variable number of "windows" per "slice"
- a variable number of "angles" filters can be glued on
- a variable number of "images"
Difficult part today is the reordering of "pizzas" in the "pizza stack". Giving that ability makes more combinations possible, but indirection has to be dealt with in code.
Testing
The good part about this problem is that tests can trivially be randomized, so it's easy to see if produced solutions work or not.
The bad part is not all randomized problem instances have a solutions. For those who do not, CP-SAT will happily burn CPUs for hours. I added a pretty arbitrary time limit.
ChatGPT
I used ChatGPT for the scaffolding work - and was quite happy with it:
> Set up a new Python 3.9 based project according to current best practices. > > The project must use the ortools library from Google (note that is a wrapper around a C++ library) > > Include support for: linting, dependency management, github codespace, tests, a Dockerfile, github actions on push and PR including and tests and lint, github actions for release of source archive and docker container on ghcr.io > > Also include a scaffolded README and LICENSE (AGPL) > > The project must compile and work cross platform, including Linux x86 and Mac arm. > > Explain every file created step by step and why
Not a perfect result, but a good result to learn from - faster than stitching together 10 blog posts (for someone not daily into an ecosystem).
- a variable number of "pizzas" ("stars with filter windows")
- a variable number of "slices" ("sectors" of stars)
- a variable number of "windows" per "slice"
- a variable number of "angles" filters can be glued on
- a variable number of "images"
-
about 2 years ago by moio | Reply
Day 3 diary: 3 failures, 1 success
Failure 1: adding the possibility of re-ordering the stack
I thought that allowing to re-ordering pizzas in the stack could help with storing more "images" - found out that as not the case. On a large set of pseudorandom tests, only an extra 4 out of 186 could be solved by changing the order. Not worth it, commit reverted.
Failure 2: going from a SAT problem to an optimization problem
CP-SAT has the cool ability of allowing to specify an objective function to minimize or maximise - making it simple to reformulate a satisfiability problem in an optimization one. I tried this approach to make the assignments more flexible but failed: I could not find a good way to mix it with the Automaton constraints which I am using to simulate light traveling through a series of filters. Path abandoned for now.
Failure 3: allowing brighter-than-specified pixels
This seemed an easy way to enlarge the solution space - interestingly, almost no effect was visible in tests. Sticking for the simpler approach (to match pixel values exactly) for now.
Success! First small four-pizza prototype works!
I am happy to report that after some serious hammering and cutting...
...and serious gluing of filter films...
...I've got a nice filter set! Notice how filtering of monitor light (which is polarized) changes with rotation!
Now I made four pizzas...
And, in the right order, they will display a programmed X pattern!
I was able to "store" 7 patterns in the four pizzas (a "Y", a "q", the "X" above, an "o", an "I", a "c" and a "K").
Next step: the bigger brother pizza with bigger patterns!
-
about 2 years ago by moio | Reply
Day 4 diary: scale up!
Today I dealt with the bigger version of the puzzle. Software scaled just fine!
About hardware I was lucky enough to get help from my son across all phases!
I am really happy with the result, here they are in all their whiteness:
What message did we hid in there? Stay tuned tomorrow for the last demo!
PS. Thanks to colleague AR about having kids do some of the job - that worked great!
-
about 2 years ago by moio | Reply
Day 5 diary: it's a wrap!
Today I created a video to explain progress and results, enjoy!
Tricky part was to get light right - so that it was clearly visible on video. Ended up with an inverted laptop screen covered with an opaque film - otherwise light comes polarized and all behavior is totally different!
Reply to moio
Day 1 diary - the physical prototyping day
Spent a bit of time into producing good SVGs with Python, then printed them and tried to find dimensions that worked (one big and one small for testing).
After few iterations decided to go with octagonal stars rather than plain octagons:
Then literally hammered out holes with a 10mm punch! Worked beautifully.
Then, cut and tested positioning of filter film:
All seems good from the physical realm so far.
Next up: coding to determine per-hole filter positioning!
# A First Level Header ## A Second Level Header Use one asterisk to *emphasize* Use two asterisks for **strong emphasis** - Use hyphens - for unordereed - lists This is an [link to example.com](http://example.com/) This is an image  This is a user link @hans This is a project link hw#some-cool-title
Reply to moio
Day 2 diary: mostly coding
CP-SAT
Learnt a lot about CP-SAT, evolved some code I had around to handle:
Difficult part today is the reordering of "pizzas" in the "pizza stack". Giving that ability makes more combinations possible, but indirection has to be dealt with in code.
Testing
The good part about this problem is that tests can trivially be randomized, so it's easy to see if produced solutions work or not.
The bad part is not all randomized problem instances have a solutions. For those who do not, CP-SAT will happily burn CPUs for hours. I added a pretty arbitrary time limit.
ChatGPT
I used ChatGPT for the scaffolding work - and was quite happy with it:
> Set up a new Python 3.9 based project according to current best practices. > > The project must use the ortools library from Google (note that is a wrapper around a C++ library) > > Include support for: linting, dependency management, github codespace, tests, a Dockerfile, github actions on push and PR including and tests and lint, github actions for release of source archive and docker container on ghcr.io > > Also include a scaffolded README and LICENSE (AGPL) > > The project must compile and work cross platform, including Linux x86 and Mac arm. > > Explain every file created step by step and why
Not a perfect result, but a good result to learn from - faster than stitching together 10 blog posts (for someone not daily into an ecosystem).
# A First Level Header ## A Second Level Header Use one asterisk to *emphasize* Use two asterisks for **strong emphasis** - Use hyphens - for unordereed - lists This is an [link to example.com](http://example.com/) This is an image  This is a user link @hans This is a project link hw#some-cool-title
Reply to moio
Day 3 diary: 3 failures, 1 success
Failure 1: adding the possibility of re-ordering the stack
I thought that allowing to re-ordering pizzas in the stack could help with storing more "images" - found out that as not the case. On a large set of pseudorandom tests, only an extra 4 out of 186 could be solved by changing the order. Not worth it, commit reverted.
Failure 2: going from a SAT problem to an optimization problem
CP-SAT has the cool ability of allowing to specify an objective function to minimize or maximise - making it simple to reformulate a satisfiability problem in an optimization one. I tried this approach to make the assignments more flexible but failed: I could not find a good way to mix it with the Automaton constraints which I am using to simulate light traveling through a series of filters. Path abandoned for now.
Failure 3: allowing brighter-than-specified pixels
This seemed an easy way to enlarge the solution space - interestingly, almost no effect was visible in tests. Sticking for the simpler approach (to match pixel values exactly) for now.
Success! First small four-pizza prototype works!
I am happy to report that after some serious hammering and cutting...
...and serious gluing of filter films...
...I've got a nice filter set! Notice how filtering of monitor light (which is polarized) changes with rotation!
Now I made four pizzas...
And, in the right order, they will display a programmed X pattern!
I was able to "store" 7 patterns in the four pizzas (a "Y", a "q", the "X" above, an "o", an "I", a "c" and a "K").
Next step: the bigger brother pizza with bigger patterns!
# A First Level Header ## A Second Level Header Use one asterisk to *emphasize* Use two asterisks for **strong emphasis** - Use hyphens - for unordereed - lists This is an [link to example.com](http://example.com/) This is an image  This is a user link @hans This is a project link hw#some-cool-title
Reply to moio
Day 4 diary: scale up!
Today I dealt with the bigger version of the puzzle. Software scaled just fine!
About hardware I was lucky enough to get help from my son across all phases!
I am really happy with the result, here they are in all their whiteness:
What message did we hid in there? Stay tuned tomorrow for the last demo!
PS. Thanks to colleague AR about having kids do some of the job - that worked great!
# A First Level Header ## A Second Level Header Use one asterisk to *emphasize* Use two asterisks for **strong emphasis** - Use hyphens - for unordereed - lists This is an [link to example.com](http://example.com/) This is an image  This is a user link @hans This is a project link hw#some-cool-title
Reply to moio
Day 5 diary: it's a wrap!
Today I created a video to explain progress and results, enjoy!
Tricky part was to get light right - so that it was clearly visible on video. Ended up with an inverted laptop screen covered with an opaque film - otherwise light comes polarized and all behavior is totally different!
# A First Level Header ## A Second Level Header Use one asterisk to *emphasize* Use two asterisks for **strong emphasis** - Use hyphens - for unordereed - lists This is an [link to example.com](http://example.com/) This is an image  This is a user link @hans This is a project link hw#some-cool-title
Similar Projects
Improve/rework household chore tracker `chorazon` by gniebler
Description
I wrote a household chore tracker named chorazon, which is meant to be deployed as a web application in the household's local network.
It features the ability to set up different (so far only weekly) schedules per task and per person, where tasks may span several days.
There are "tokens", which can be collected by users. Tasks can (and usually will) have rewards configured where they yield a certain amount of tokens. The idea is that they can later be redeemed for (surprise) gifts, but this is not implemented yet. (So right now one needs to edit the DB manually to subtract tokens when they're redeemed.)
Days are not rolled over automatically, to allow for task completion control.
We used it in my household for several months, with mixed success. There are many limitations in the system that would warrant a revisit.
It's written using the Pyramid Python framework with URL traversal, ZODB as the data store and Web Components for the frontend.
Goals
- Add admin screens for users, tasks and schedules
- Add models, pages etc. to allow redeeming tokens for gifts/surprises
- …?
Resources
tbd (Gitlab repo)
Enhance git-sha-verify: A tool to checkout validated git hashes by gpathak
Description
git-sha-verify is a simple shell utility to verify and checkout trusted git commits signed using GPG key. This tool helps ensure that only authorized or validated commit hashes are checked out from a git repository, supporting better code integrity and security within the workflow.
Supports:
- Verifying commit authenticity signed using gpg key
- Checking out trusted commits
Ideal for teams and projects where the integrity of git history is crucial.
Goals
A minimal python code of the shell script exists as a pull request.
The goal of this hackweek is to:
- Add more unit tests
- Make the python code modular
- Add code coverage if possible
Resources
- Link to GitHub Repository: https://github.com/openSUSE/git-sha-verify
Improve chore and screen time doc generator script `wochenplaner` by gniebler
Description
I wrote a little Python script to generate PDF docs, which can be used to track daily chore completion and screen time usage for several people, with one page per person/week.
I named this script wochenplaner and have been using it for a few months now.
It needs some improvements and adjustments in how the screen time should be tracked and how chores are displayed.
Goals
- Fix chore field separation lines
- Change screen time tracking logic from "global" (week-long) to daily subtraction and weekly addition of remainders (more intuitive than current "weekly time budget method)
- Add logic to fill in chore fields/lines, ideally with pictures, falling back to text.
Resources
tbd (Gitlab repo)
Update M2Crypto by mcepl
There are couple of projects I work on, which need my attention and putting them to shape:
Goal for this Hackweek
- Put M2Crypto into better shape (most issues closed, all pull requests processed)
- More fun to learn jujutsu
- Play more with Gemini, how much it help (or not).
- Perhaps, also (just slightly related), help to fix vis to work with LuaJIT, particularly to make vis-lspc working.
Bring to Cockpit + System Roles capabilities from YAST by miguelpc
Bring to Cockpit + System Roles features from YAST
Cockpit and System Roles have been added to SLES 16 There are several capabilities in YAST that are not yet present in Cockpit and System Roles We will follow the principle of "automate first, UI later" being System Roles the automation component and Cockpit the UI one.
Goals
The idea is to implement service configuration in System Roles and then add an UI to manage these in Cockpit. For some capabilities it will be required to have an specific Cockpit Module as they will interact with a reasource already configured.
Resources
A plan on capabilities missing and suggested implementation is available here: https://docs.google.com/spreadsheets/d/1ZhX-Ip9MKJNeKSYV3bSZG4Qc5giuY7XSV0U61Ecu9lo/edit
Linux System Roles: https://linux-system-roles.github.io/
First meeting Hackweek catchup
- Monday, December 1 · 11:00 – 12:00
- Time zone: Europe/Madrid
- Google Meet link: https://meet.google.com/rrc-kqch-hca
Improve chore and screen time doc generator script `wochenplaner` by gniebler
Description
I wrote a little Python script to generate PDF docs, which can be used to track daily chore completion and screen time usage for several people, with one page per person/week.
I named this script wochenplaner and have been using it for a few months now.
It needs some improvements and adjustments in how the screen time should be tracked and how chores are displayed.
Goals
- Fix chore field separation lines
- Change screen time tracking logic from "global" (week-long) to daily subtraction and weekly addition of remainders (more intuitive than current "weekly time budget method)
- Add logic to fill in chore fields/lines, ideally with pictures, falling back to text.
Resources
tbd (Gitlab repo)
Improve/rework household chore tracker `chorazon` by gniebler
Description
I wrote a household chore tracker named chorazon, which is meant to be deployed as a web application in the household's local network.
It features the ability to set up different (so far only weekly) schedules per task and per person, where tasks may span several days.
There are "tokens", which can be collected by users. Tasks can (and usually will) have rewards configured where they yield a certain amount of tokens. The idea is that they can later be redeemed for (surprise) gifts, but this is not implemented yet. (So right now one needs to edit the DB manually to subtract tokens when they're redeemed.)
Days are not rolled over automatically, to allow for task completion control.
We used it in my household for several months, with mixed success. There are many limitations in the system that would warrant a revisit.
It's written using the Pyramid Python framework with URL traversal, ZODB as the data store and Web Components for the frontend.
Goals
- Add admin screens for users, tasks and schedules
- Add models, pages etc. to allow redeeming tokens for gifts/surprises
- …?
Resources
tbd (Gitlab repo)
openQA log viewer by mpagot
Description
*** Warning: Are You at Risk for VOMIT? ***
Do you find yourself staring at a screen, your eyes glossing over as thousands of lines of text scroll by? Do you feel a wave of text-based nausea when someone asks you to "just check the logs"?
You may be suffering from VOMIT (Verbose Output Mental Irritation Toxicity).
This dangerous, work-induced ailment is triggered by exposure to an overwhelming quantity of log data, especially from parallel systems. The human brain, not designed to mentally process 12 simultaneous autoinst-log.txt files, enters a state of toxic shock. It rejects the "Verbose Output," making it impossible to find the one critical error line buried in a 50,000-line sea of "INFO: doing a thing."
Before you're forced to rm -rf /var/log in a fit of desperation, we present the digital antacid.
No panic: The openQA Log Visualizer (Also known as the "VOMIT-B-Gone 9000")
This is your web-based hazmat suit for handling toxic log environments. It bravely dives into the chaotic, multi-machine mess of your openQA test runs, finds all the related, verbose logs, and force-feeds them into a parser.
Goals
Work on the existing POC openqa-log-visualizer and change it to something usable
Resources
AI-Powered Unit Test Automation for Agama by joseivanlopez
The Agama project is a multi-language Linux installer that leverages the distinct strengths of several key technologies:
- Rust: Used for the back-end services and the core HTTP API, providing performance and safety.
- TypeScript (React/PatternFly): Powers the modern web user interface (UI), ensuring a consistent and responsive user experience.
- Ruby: Integrates existing, robust YaST libraries (e.g.,
yast-storage-ng) to reuse established functionality.
The Problem: Testing Overhead
Developing and maintaining code across these three languages requires a significant, tedious effort in writing, reviewing, and updating unit tests for each component. This high cost of testing is a drain on developer resources and can slow down the project's evolution.
The Solution: AI-Driven Automation
This project aims to eliminate the manual overhead of unit testing by exploring and integrating AI-driven code generation tools. We will investigate how AI can:
- Automatically generate new unit tests as code is developed.
- Intelligently correct and update existing unit tests when the application code changes.
By automating this crucial but monotonous task, we can free developers to focus on feature implementation and significantly improve the speed and maintainability of the Agama codebase.
Goals
- Proof of Concept: Successfully integrate and demonstrate an authorized AI tool (e.g.,
gemini-cli) to automatically generate unit tests. - Workflow Integration: Define and document a new unit test automation workflow that seamlessly integrates the selected AI tool into the existing Agama development pipeline.
- Knowledge Sharing: Establish a set of best practices for using AI in code generation, sharing the learned expertise with the broader team.
Contribution & Resources
We are seeking contributors interested in AI-powered development and improving developer efficiency. Whether you have previous experience with code generation tools or are eager to learn, your participation is highly valuable.
If you want to dive deep into AI for software quality, please reach out and join the effort!
- Authorized AI Tools: Tools supported by SUSE (e.g.,
gemini-cli) - Focus Areas: Rust, TypeScript, and Ruby components within the Agama project.
Interesting Links
Bugzilla goes AI - Phase 1 by nwalter
Description
This project, Bugzilla goes AI, aims to boost developer productivity by creating an autonomous AI bug agent during Hackweek. The primary goal is to reduce the time employees spend triaging bugs by integrating Ollama to summarize issues, recommend next steps, and push focused daily reports to a Web Interface.
Goals
To reduce employee time spent on Bugzilla by implementing an AI tool that triages and summarizes bug reports, providing actionable recommendations to the team via Web Interface.
Project Charter
https://docs.google.com/document/d/1HbAvgrg8T3pd1FIx74nEfCObCljpO77zz5In_Jpw4as/edit?usp=sharing## Description
"what is it" file and directory analysis via MCP and local LLM, for console and KDE by rsimai
Description
Users sometimes wonder what files or directories they find on their local PC are good for. If they can't determine from the filename or metadata, there should an easy way to quickly analyze the content and at least guess the meaning. An LLM could help with that, through the use of a filesystem MCP and to-text-converters for typical file types. Ideally this is integrated into the desktop environment but works as well from a console. All data is processed locally or "on premise", no artifacts remain or leave the system.
Goals
- The user can run a command from the console, to check on a file or directory
- The filemanager contains the "analyze" feature within the context menu
- The local LLM could serve for other use cases where privacy matters
TBD
- Find or write capable one-shot and interactive MCP client
- Find or write simple+secure file access MCP server
- Create local LLM service with appropriate footprint, containerized
- Shell command with options
- KDE integration (Dolphin)
- Package
- Document
Resources
Background Coding Agent by mmanno
Description
I had only bad experiences with AI one-shots. However, monitoring agent work closely and interfering often did result in productivity gains.
Now, other companies are using agents in pipelines. That makes sense to me, just like CI, we want to offload work to pipelines: Our engineering teams are consistently slowed down by "toil": low-impact, repetitive maintenance tasks. A simple linter rule change, a dependency bump, rebasing patch-sets on top of newer releases or API deprecation requires dozens of manual PRs, draining time from feature development.
So far we have been writing deterministic, script-based automation for these tasks. And it turns out to be a common trap. These scripts are brittle, complex, and become a massive maintenance burden themselves.
Can we make prompts and workflows smart enough to succeed at background coding?
Goals
We will build a platform that allows engineers to execute complex code transformations using prompts.
By automating this toil, we accelerate large-scale migrations and allow teams to focus on high-value work.
Our platform will consist of three main components:
- "Change" Definition: Engineers will define a transformation as a simple, declarative manifest:
- The target repositories.
- A wrapper to run a "coding agent", e.g., "gemini-cli".
- The task as a natural language prompt.
- The target repositories.
- "Change" Management Service: A central service that orchestrates the jobs. It will receive Change definitions and be responsible for the job lifecycle.
- Execution Runners: We could use existing sandboxed CI runners (like GitHub/GitLab runners) to execute each job or spawn a container.
MVP
- Define the Change manifest format.
- Build the core Management Service that can accept and queue a Change.
- Connect management service and runners, dynamically dispatch jobs to runners.
- Create a basic runner script that can run a hard-coded prompt against a test repo and open a PR.
Stretch Goals:
- Multi-layered approach, Workflow Agents trigger Coding Agents:
- Workflow Agent: Gather information about the task interactively from the user.
- Coding Agent: Once the interactive agent has refined the task into a clear prompt, it hands this prompt off to the "coding agent." This background agent is responsible for executing the task and producing the actual pull request.
- Workflow Agent: Gather information about the task interactively from the user.
- Use MCP:
- Workflow Agent gathers context information from Slack, Github, etc.
- Workflow Agent triggers a Coding Agent.
- Workflow Agent gathers context information from Slack, Github, etc.
- Create a "Standard Task" library with reliable prompts.
- Rebasing rancher-monitoring to a new version of kube-prom-stack
- Update charts to use new images
- Apply changes to comply with a new linter
- Bump complex Go dependencies, like k8s modules
- Backport pull requests to other branches
- Rebasing rancher-monitoring to a new version of kube-prom-stack
- Add “review agents” that review the generated PR.
See also
Multi-agent AI assistant for Linux troubleshooting by doreilly
Description
Explore multi-agent architecture as a way to avoid MCP context rot.
Having one agent with many tools bloats the context with low-level details about tool descriptions, parameter schemas etc which hurts LLM performance. Instead have many specialised agents, each with just the tools it needs for its role. A top level supervisor agent takes the user prompt and delegates to appropriate sub-agents.
Goals
Create an AI assistant with some sub-agents that are specialists at troubleshooting Linux subsystems, e.g. systemd, selinux, firewalld etc. The agents can get information from the system by implementing their own tools with simple function calls, or use tools from MCP servers, e.g. a systemd-agent can use tools from systemd-mcp.
Example prompts/responses:
user$ the system seems slow
assistant$ process foo with pid 12345 is using 1000% cpu ...
user$ I can't connect to the apache webserver
assistant$ the firewall is blocking http ... you can open the port with firewall-cmd --add-port ...
Resources
Language TBD - golang or python. Python ADK seems more mature, but golang is easier to package.
https://google.github.io/adk-docs/
Port some classic game to Linux by MDoucha
Let's pick some old classic game, reverse engineer the data formats and game rules and write an open source engine for it from scratch. Some games from 1990s are simple enough that we could have a playable prototype by the end of the week.
Write which games you'd like to hack on in the comments. Don't forget to check e.g. on Open Source Game Clones, Github and SourceForge whether the game is ported already.
Hack Week 25 - TBD
It's time to pick a game for the upcoming Hack Week. Discuss in the comments what game you'd like to hack!
Hack Week 24 - Master of Orion II: Battle at Antares & Chaos Overlords
Work on Master of Orion II continues but we can hack more than one game. Chaos Overlords is a dystopian, lighthearted, cyberpunk turn-based strategy game originally released in 1996 for Windows 95 and Mac OS. The player takes on the role of a Chaos Overlord, attempting to control a city. Gameplay involves hiring mercenary gangs and deploying them on an 8-by-8 grid of city sectors to generate income, occupy sectors and take over the city.
How to ~~install & play~~ observe the decompilation progress:
- Clone the Git repository
- A playable reimplementation does not exist yet, but when it does, it will be linked in the repository mentioned above.
Further work needed:
- Analyze the remaining unknown data structures, most of which are related to the AI.
- Decompile the AI completely. The strong AI is part of the appeal of the game. It cannot be left out.
- Reimplement the game.
Hack Week 20, 21, 22 & 23 - Master of Orion II: Battle at Antares
Master of Orion II is one of the greatest turn-based 4X games of the 1990s. Explore the galaxy, colonize planets, research new technologies, fight space monsters and alien empires and in the end, become the ruler of the galaxy one way or another.
How to install & play:
- Clone the Git repository
- Run
./bootstrap; ./configure; make && make install - Copy all *.LBX files from the original Master of Orion II to the installation data directory (
/usr/local/share/openorion2by default) - Run
openorion2
Further work needed:
- Analyze the rest of the original savegame format and a few remaining data files.
- Implement most of the game. The open source engine currently supports only loading saved games from the original version and viewing the galaxy map, fleet management and list of known planets.
Hack Week 19 - Signus: The Artifact Wars
Signus is a Czech turn-based strategy game similar to Panzer General or Battle Isle series. Originally published in 1998 and open-sourced by the original developers in 2003.
How to install & play:
- Clone the Git repository
- Run
./bootstrap; ./configure; make && make installin bothsignusandsignus-datadirectories. - Run
signus
Further work needed:
Advent of Code: The Diaries by amanzini
Description
It was the Night Before Compile Time ...
Hackweek 25 (December 1-5) perfectly coincides with the first five days of Advent of Code 2025. This project will leverage this overlap to participate in the event in real-time.
To add a layer of challenge and exploration (in the true spirit of Hackweek), the puzzles will be solved using a non-mainstream, modern language like Ruby, D, Crystal, Gleam or Zig.
The primary project intent is not just simply to solve the puzzles, but to exercise result sharing and documentation. I'd create a public-facing repository documenting the process. This involves treating each day's puzzle as a mini-project: solving it, then documenting the solution with detailed write-ups, analysis of the language's performance and ergonomics, and visualizations.
|
\ ' /
-- (*) --
>*<
>0<@<
>>>@<<*
>@>*<0<<<
>*>>@<<<@<<
>@>>0<<<*<<@<
>*>>0<<@<<<@<<<
>@>>*<<@<>*<<0<*<
\*/ >0>>*<<@<>0><<*<@<<
___\\U//___ >*>>@><0<<*>>@><*<0<<
|\\ | | \\| >@>>0<*<0>>@<<0<<<*<@<<
| \\| | _(UU)_ >((*))_>0><*<0><@<<<0<*<
|\ \| || / //||.*.*.*.|>>@<<*<<@>><0<<<
|\\_|_|&&_// ||*.*.*.*|_\\db//_
""""|'.'.'.|~~|.*.*.*| ____|_
|'.'.'.| ^^^^^^|____|>>>>>>|
~~~~~~~~ '""""`------'
------------------------------------------------
This ASCII pic can be found at
https://asciiart.website/art/1831
Goals
Code, Docs, and Memes: An AoC Story
Have fun!
Involve more people, play together
Solve Days 1-5: Successfully solve both parts of the Advent of Code 2025 puzzles for Days 1-5 using the chosen non-mainstream language.
Daily Documentation & Language Review: Publish a detailed write-up for each day. This documentation will include the solution analysis, the chosen algorithm, and specific commentary on the language's ergonomics, performance, and standard library for the given task.