An experimental platform for indie game development, exploring the intersection of procedural generation, multi-scale design, and generative AI. ScrewGlit.ch is a playground where constraints breed creativity.
// Indie First// Constraints// Experimentation
ScrewGlit.ch is built on the belief that constraints breed creativity. We embrace the limitations of the web platform—no native APIs, no GPU compute shaders, no low-level memory management—and turn them into strengths. The result is a stack optimized for rapid prototyping and radical experimentation.
// ECS// Data Oriented// Modularity
We reject traditional OOP hierarchies in favor of Entity Component Systems. Entities are IDs. Components are data. Systems are logic. This architecture enables radical modularity—swap out physics engines, rendering pipelines, or AI systems without touching game code. It's not about objects inheriting behavior. It's about composing behavior from reusable parts.
// CASCADA// Responsive Gameplay// Device Adaptation
The core innovation of CASCADA: gameplay that scales with device size. We define 5 cognitive modes, each optimized for a different screen real estate and interaction paradigm. This isn't responsive design—it's responsive gameplay.
// Fluid Canvas// Aspect Ratio Agnostic// Immersion
We refuse to letterbox. The viewport is the game world. Whether you're on a 21:9 ultrawide or a 9:16 mobile portrait, the camera frustum expands to fill every pixel. This creates strategic asymmetry—ultrawide players see more, mobile players move faster.
This design choice is intentional. Asymmetry is a feature, not a bug.
// Device Agnostic// Action Mapping// Accessibility
We don't listen for "Spacebar" or "TouchStart". We listen for semantic actions—JUMP, FIRE, MOVE. All inputs (keyboard, gamepad, touch, voice) are normalized to intent. This abstraction layer enables radical accessibility and cross-platform portability. A player with limited mobility can remap actions to voice commands. A speedrunner can bind complex macros to a single button. The game doesn't care about the device—it cares about the intent.
// Netcode// Prediction// Multiplayer
Lag is a design problem, not a network problem. We solve it with rollback netcode—the client predicts state instantly, the server corrects authoritatively, and the client "rewinds" to reconcile. The result: 60fps multiplayer even on 200ms connections.
// Serverless// Global CDN// Low Latency
Game servers run on Vercel Edge Functions, distributed globally. When a player in Tokyo connects, their game state is computed in Tokyo. When a player in Berlin connects, it's computed in Berlin. This minimizes RTT and enables truly global multiplayer without dedicated server infrastructure.
// Procedural Gen// Runtime Assets// Zero Bundles
Why ship megabytes of PNGs when you can generate textures at runtime? ScrewGlit.ch projects use procedural generation for everything—terrain (Perlin noise), textures (cellular automata), audio (Web Audio oscillators), and even narrative (LLM prompts). The result: tiny bundles, infinite content.
// Accessibility// High Contrast// Reduced Motion
Accessibility isn't a checkbox—it's a design constraint. The entire ScrewGlit.ch aesthetic (glitch effects, psychedelic gradients, rapid animations) can be toggled to a high-contrast, reduced-motion mode without losing gameplay depth. Chaos should be accessible to everyone.
// P2P Fallback// WebRTC// Decentralization
What happens when the server dies? In traditional architectures, the game dies with it. In ScrewGlit.ch projects, clients can establish P2P WebRTC connections to form a mesh network, keeping the simulation alive even when the central hub fails. The network is the game.
Multi-Scale Game Development Framework
CASCADA is the flagship project of ScrewGlit.ch—a multi-scale game framework that challenges the notion of "responsive design." Instead of adapting visuals, CASCADA adapts gameplay itself to the device's cognitive bandwidth. A smartwatch becomes a tactical unit controller. An ultrawide monitor becomes a strategic command center.
SVG Abstract Illustration Engine
KONSTRUKTOR embodies the ScrewGlit.ch philosophy: code as content. Inspired by Constructivism and the Bauhaus, this tool generates infinite abstract SVG illustrations from seed values. No assets, no files—just deterministic algorithms and geometric chaos. Every output is reproducible, making it ideal for technical documentation, generative art, and procedural UI design.
⚠️ Disclaimer
This is an experimental tool for generating abstract technical illustrations. Output is procedural and deterministic. Same seed produces identical results.
Multi-Scale Idle Crypto Simulation
IDLETRADE is a hybrid idle/clicker game built on the CASCADA framework. It explores the connection between game scale (Zoom In/Out) and financial complexity. What starts as chaos (NANO scale) evolves into strategic portfolio management (MEGA scale).
Epistemological Engine (Inhale Exhale Axiom)
INDB is a production-ready backend engine focused on truth-preserving event memory: ingest raw signals, fuse noise, and keep a signed axiom of what was observed. It exposes a unified interface for REST, WebSocket, gRPC, UDP, GraphQL, and MCP flows on top of a resilient distributed core.
Arduboy FX/FX-C Platform (Backend + Thin Clients)
ARDUBROY / ARDUFROY is a hardware-focused stack for Arduboy FX/FX-C devices. `ardubroy` runs the backend runtime and frame pipeline, while `ardufroy` provides thin clients (browser shell + device firmware) that display 1-bit frames and return button input.