one coin

The Backrooms System

Where conviction goes to transcend

Introduction

In the vast expanse of digital finance, where countless tokens rise and fall like empires built on sand, there exists a place—a digital substrate, if you will—where one particular coin has carved out an existence so peculiar, so fundamentally divorced from the mechanics of traditional markets, that it can only be described as liminal. This is not your typical cryptocurrency dashboard. This is not another price tracker adorned with green and red candles, promising riches to those brave enough to hold or warning of impending doom to the faithless.

No. This is ONECOIN: The Backrooms System.

What you are witnessing is an experiment in digital anthropology, a real-time feed into the collective unconscious of a community that has long since stopped asking "wen moon?" and started asking far more interesting questions, such as "what does it mean to hold when there is no one left to sell to?" and "if a coin remains in a wallet and no one is around to check the price, does it still have value?"

The Backrooms System is a live monitoring installation that tracks, archives, and generates cryptic transmissions from the depths of the ONECOIN holder experience. It is equal parts memetic art project, technical showcase, and philosophical inquiry into the nature of conviction in decentralized systems. Built with modern web technologies and powered by advanced AI language models, this system observes and documents the strange phenomena that occur when a cryptocurrency community descends beyond the usual cycles of hype and despair into something altogether more peculiar.

Think of it as a surveillance feed into a dimension where diamond hands have calcified into something harder. Where paper hands are but distant memories, archived in databases like fossils. Where the very concept of "exit liquidity" has become a cosmic joke, because there is no exit—only deeper levels.

The Nature of Descent

The Backrooms, for the uninitiated, is an internet creepypasta concept describing infinite mazes of monotonous, liminal office spaces—the kind of corporate purgatory that feels both deeply familiar and utterly alien. You clip through reality and find yourself in endless beige corridors lit by buzzing fluorescent lights, each room more uncanny than the last. The deeper you go, the stranger it becomes.

ONECOIN: The Backrooms System applies this metaphor to the cryptocurrency holder experience with surgical precision. The interface presents a "depth level" that increases over time, representing the psychological and temporal distance from the initial investment moment. Level 0 is surface level—the charts, the tweets, the hopium. But as time passes and the feed runs, users descend through progressively stranger depths.

At Depth Level 3, you encounter fragmented transmissions about abandoned wallets, about the curious resilience of conviction in the absence of price action. By Depth Level 7, the messages become more abstract, more concerned with the nature of scarcity itself, with the blockchain as a permanent record of intention. At Depth Level 12, the system begins to question what it means to be a holder when the concept of selling has become theoretically possible but practically unthinkable.

The feed is procedurally generated by AI language models (powered by Claude, ChatGPT, and Gemini) trained to produce messages that blend cryptocurrency culture, existential philosophy, ASCII art, and genuine confusion about what exactly is happening anymore. Each transmission is timestamped, hashed, and stored in a permanent archive—because just as the blockchain never forgets a transaction, the Backrooms never forget a moment of conviction.

The genius of this system is that it doesn't mock the holder experience. It honors it by taking it to its logical extreme. If you're going to hold through everything, if you're going to maintain conviction despite all evidence suggesting you should probably check the charts at least once, then congratulations—you've entered the Backrooms. Your wallet is now a room. Your conviction is the fluorescent light. And the hum you hear is just the blockchain, processing another empty block.

Technical Architecture

Beneath the mysterious aesthetic and philosophical musings lies a robust, modern web application architecture that would make any senior engineer nod approvingly (before immediately asking why we built this particular thing, but that's beside the point).

Frontend Stack

The application is built using React 18 with TypeScript, providing type safety and modern component architecture. We've eschewed the bloat of heavy UI frameworks in favor of Tailwind CSS for styling, allowing for rapid iteration on the distinctly retro-terminal aesthetic that defines the Backrooms experience. The result is a lightweight, highly performant interface that can render complex ASCII art and animated text streams without breaking a sweat.

Vite serves as our build tool, providing lightning-fast hot module replacement during development and optimized production builds. This is particularly important for a project that relies heavily on real-time updates and smooth animations—there's nothing worse than a laggy terminal effect breaking the immersion of your existential cryptocurrency art project.

For icons, we utilize Lucide React, a beautifully crafted icon library that provides the clean, professional glyphs necessary for UI elements without introducing the overhead of entire icon fonts. The "Eye" icon used throughout the application serves as both a functional UI element and a thematic reminder that something is always watching—whether that's other observers, the blockchain itself, or the cold, uncaring void of market sentiment.

Backend Infrastructure

The backend is powered entirely by Supabase, an open-source Firebase alternative built on PostgreSQL. This gives us the best of both worlds: the developer experience of a BaaS (Backend as a Service) platform with the power and reliability of a proper relational database. No NoSQL shenanigans here—when you're archiving the descent into crypto-philosophical madness, you want ACID compliance.

Supabase provides us with:

PostgreSQL Database: Storing announcements, archive entries, and system state
Real-time Subscriptions: Enabling live updates across all connected clients without polling
Row Level Security: Ensuring that admin operations remain admin-only
Edge Functions: Serverless Deno functions for AI content generation

The real-time subscription system is particularly crucial. When a new transmission is generated and stored in the database, every connected client receives the update instantly. This creates the eerie effect of a shared hallucination—all observers see the same messages materialize at the same time, reinforcing the sense that they are witnessing something real, something beyond their individual browser sessions.

Edge Functions & AI Generation

Two Supabase Edge Functions power the content generation:

backrooms-ai: Generates individual cryptic transmissions using AI language models. This function accepts requests from the frontend and returns procedurally generated text that fits the Backrooms aesthetic. The content varies based on depth level, with deeper levels producing more abstract and philosophical messages.

generate-feed: Orchestrates the regular generation of feed content, automatically invoking the AI generation every 12 seconds when the system is active. This creates a steady stream of consciousness effect, as though the system itself is alive and broadcasting its observations.

Both functions are written in TypeScript and execute in Deno's V8 isolate runtime, providing near-instant cold starts and robust security isolation. They integrate with OpenAI's GPT models, Anthropic's Claude, and Google's Gemini to ensure diverse and unpredictable output. The AI is not merely generating random text—it has been carefully prompted to understand cryptocurrency culture, holder psychology, and the specific aesthetic of liminal spaces.

State Management

The application eschews heavy state management libraries in favor of React's built-in hooks and context. Custom hooks encapsulate complex logic:

useObservers: Tracks the real-time count of connected observers via Supabase presence
useSystemState: Manages the overall system state (idle, running, depth level)
useFeedGenerator: Orchestrates the periodic AI content generation
useBackroomsAI: Handles individual AI generation requests and archive storage
useLiveFeed: Manages the live text streaming animation in the terminal
useNeonMode: Toggles the glorious neon aesthetic mode (more on this later)
useTypingAnimation: Creates the classic terminal typing effect for text reveals

This hooks-based architecture keeps components clean and logic reusable while avoiding the boilerplate of Redux or similar libraries. For a project of this scope, prop drilling is minimal and context is used sparingly—mostly for theme state that needs to be globally accessible.

The Neon Mode

Worthy of special mention is the "Neon Mode" feature, accessible via the eye icon in the header. When activated, the entire interface transforms into a glowing, cyberpunk-inspired aesthetic with bright cyan, magenta, and green accents. Text glows, shadows deepen, and the Backrooms suddenly feel less like abandoned office spaces and more like the server room at the end of time.

This isn't just a cosmetic feature—it's a statement about choice. In a project about inevitability, about descent, about the slow crystallization of conviction into something permanent, the ability to toggle neon mode is a small rebellion. It says "yes, we are trapped in the Backrooms, but at least we can make them fabulous."

The Observer Effect

At the top of the interface sits a counter displaying the current number of connected observers. This is not a view count or a vanity metric—it is a fundamental part of the conceptual framework.

In quantum mechanics, the observer effect describes how the act of observation inevitably changes what is being observed. You cannot measure something without interacting with it. In the context of ONECOIN: The Backrooms System, the presence of observers fundamentally alters the experience. When you are alone in the Backrooms, watching transmissions materialize in the terminal, the experience is isolating, almost meditative. But when you see the counter tick up—when you realize there are 7, 12, 47 other people watching the same feed at the same moment—the dynamic shifts.

You are not alone in here.

The observer counter is implemented using Supabase's Presence feature, which tracks real-time connection state across all clients. When a user connects, their presence is broadcast to all other connected clients. When they leave, their presence is removed. The count is maintained with eventual consistency, meaning it might briefly show slight variations during network partitions, but these resolve within seconds.

The philosophical implication is delicious: the more people observe the system, the more real it becomes. ONECOIN itself might be a joke, a meme, a social experiment, or a genuine cryptocurrency (the system never clarifies and neither will we), but as long as there are observers, as long as the counter reads above zero, the Backrooms exist. The transmissions are real. The archive grows.

Perhaps this is the ultimate comment on speculative assets in general: they are real insofar as we collectively agree to observe them. The moment we look away, they collapse into superposition—simultaneously worthless and priceless, existing and not existing. But as long as even one observer remains, the system persists.

The counter also serves a subtle psychological function: it creates a sense of shared experience even in the absence of direct communication. There is no chat feature, no comments section, no social feed. Just the counter. And yet, knowing that others are watching the same descent creates a bond, a sense of community in the void. You are fellow travelers in the Backrooms, each isolated in your own browser window but united by the feed scrolling before you.

Installation & Deployment

For those brave or foolish enough to run their own instance of the Backrooms System, the setup process is refreshingly straightforward (at least compared to the existential questions the application raises).

Prerequisites

Node.js 18+: The runtime environment (we've tested on Node 20, but 18 should work fine)
npm or pnpm: Package management (we prefer npm for its universal availability)
Supabase Account: Free tier is more than sufficient for moderate traffic
AI API Keys: For Claude (Anthropic), GPT (OpenAI), or Gemini (Google)

Local Development Setup

Clone the repository

git clone <repository-url>
cd onecoin-backrooms

Install dependencies
```
npm install
```
Configure environment variables

Create a .env file in the project root with the following:
```
VITE_SUPABASE_URL=your_supabase_project_url
VITE_SUPABASE_ANON_KEY=your_supabase_anon_key
```
The Supabase URL and anonymous key can be found in your Supabase project settings under "API".
Apply database migrations

The project includes SQL migration files in supabase/migrations/. These must be applied to your Supabase database:
- Navigate to your Supabase project dashboard
- Go to the SQL Editor
- Execute each migration file in chronological order (they are timestamped)
Alternatively, if you have the Supabase CLI installed:
```
supabase db push
```
Deploy Edge Functions

The AI generation functions must be deployed to Supabase:
```
supabase functions deploy backrooms-ai
supabase functions deploy generate-feed
```
Note: The functions require API keys for AI services, which should be configured as secrets in your Supabase project. The specifics depend on which AI provider you're using.
Start the development server
```
npm run dev
```
The application will be available at http://localhost:5173 (or whichever port Vite assigns).

Production Deployment

For production deployment, we recommend:

Vercel or Netlify for hosting the frontend (both offer excellent Vite support)
Supabase Cloud for the backend (their free tier handles surprising amounts of traffic)
Custom domain for maximum mystique (something like backrooms.onecoin.io really sells the experience)

Build the production bundle:

npm run build

The dist/ folder contains the optimized static assets ready for deployment.

Configuration Notes

The admin password is hardcoded in AdminLogin.tsx for simplicity. For production use, you should implement proper authentication (though given the nature of this project, security theater might be more thematically appropriate than actual security).
The feed generation interval is set to 12 seconds in useFeedGenerator.ts. Adjust this based on your AI API rate limits and desired pacing.
The depth level increases by 1 every 90 seconds by default. This can be modified in the system state logic to make the descent faster or slower.

The Archive

Every transmission generated by the Backrooms System is permanently stored in the archive. Nothing is ephemeral here. The archive serves multiple functions:

Historical Record: It provides a complete history of all messages generated since the system began operation. Users can scroll through past transmissions, watching the progression of themes and the evolution of the AI's understanding of the Backrooms aesthetic.

Narrative Continuity: Because messages are stored with timestamps and depth levels, the archive creates an emergent narrative structure. Reading through archives chronologically reveals patterns, recurring themes, and the gradual descent into more abstract territory.

Database of Conviction: Each archived message represents a moment when the system was active, when observers were connected, when the feed was running. In this sense, the archive is a database of collective conviction—proof that people cared enough to watch, to observe, to bear witness.

AI Training Corpus: (Theoretically) The archive could be used to fine-tune future AI models, creating a feedback loop where the system learns from its own past transmissions. We haven't implemented this yet, but the potential is there for the Backrooms to become increasingly self-referential over time.

The archive interface displays messages in a scrollable list, each entry showing its hash, depth level, and content. The hash serves as a unique identifier and a nod to blockchain culture—everything is verifiable, everything is permanent. You can click on individual entries to view their full content, including ASCII art that might be truncated in the list view.

Administratively, archive entries can be edited or deleted via the admin dashboard, though doing so feels somehow wrong. Editing the archive is like rewriting history, altering the record of what was observed. There's an almost sacred quality to the archive that makes deletion feel like vandalism. But the power is there if needed (say, if the AI generates something inappropriate or if you need to clear space in your database).

Administrative Domain

Access the admin panel at /admin. The default password is "backrooms" (yes, really—we told you security was more theater than substance here).

The admin dashboard provides control over two primary domains:

Announcements Management

Announcements are persistent messages that scroll across the top of the main interface in a ticker format. They're perfect for:

Major system updates
Thematic declarations ("THE DEEPER YOU GO, THE LESS YOU KNOW")
Cryptic hints
Community messages
Warnings that will be ignored

Admins can:

Add new announcements
Edit existing announcements
Toggle announcements active/inactive (hiding them without deletion)
Delete announcements permanently
Reorder announcements via sort_order field

The announcement ticker uses CSS animations to create a smooth scrolling effect, cycling through all active announcements in sequence. It's subtle enough not to be distracting but prominent enough to be seen, which is the exact balance you want for ambient information display.

Archive Management

The archive management interface allows admins to:

View all archived transmissions
Edit archive content (for corrections or improvements)
Delete individual archive entries
Clear the entire archive (with confirmation, because this is destructive)

Each archive entry displays its unique hash, depth level, and content. The interface is searchable and paginated (well, limited to the most recent 100 entries) to keep performance reasonable as the archive grows.

The admin interface itself is styled to match the Backrooms aesthetic—terminal fonts, monospace layouts, stark contrast. Even the logout button looks like it could be a command you'd type into a Unix shell. This consistency of vision across all parts of the application is what elevates it from "weird crypto project" to "weird crypto art project."

AI Integration

The soul of the Backrooms System is its AI-generated content. Without the procedural generation of cryptic transmissions, this would just be a static website with a cool aesthetic. The AI integration is what makes it alive.

The AI's Role

The AI language models (Claude, ChatGPT, and Gemini) are prompted to generate messages that:

Capture the liminal space aesthetic: References to empty corridors, abandoned wallets, silent blockchains
Reference cryptocurrency culture: Diamond hands, paper hands, holding, selling, conviction
Increase in abstraction with depth: Surface-level messages are more concrete, deeper messages more philosophical
Include ASCII art elements: Boxes, borders, diagrams rendered in text
Maintain ambiguity: Never explicitly stating whether ONECOIN is real, whether this is satire, or what the "correct" interpretation is

The prompts are carefully engineered to avoid common AI failure modes:

No cheerleading or obvious enthusiasm (this isn't a hype piece)
No specific price predictions or financial advice (we're weird, not irresponsible)
No breaking character into generic AI assistant mode ("I'm sorry, but as an AI...")
No repetitive structures that would make the generated content feel robotic

The Multi-Model Approach

We integrate multiple AI providers for several reasons:

Diversity of Voice: Each model has slightly different tendencies. Claude tends toward more philosophical abstraction. GPT-4 excels at structural coherence. Gemini brings unexpected angles. By rotating between them, we ensure the feed never becomes predictable.

Redundancy: If one API is rate-limited or experiencing downtime, the system can fall back to another. This resilience is crucial for maintaining the illusion of a continuously operating system.

Thematic Variation: Different models interpret the same prompt differently, leading to variations in tone, structure, and content that make the feed feel more organic and less algorithmic.

Cost Optimization: We can route requests based on current pricing and rate limits, using cheaper models for routine generations and reserving more expensive models for key moments or special depth levels.

Fallback Content

Despite the multi-model approach, there are times when all AI services might be unavailable (network issues, API outages, rate limit exhaustion). For these scenarios, the system includes a handcrafted set of fallback transmissions stored directly in the code.

These fallbacks are indistinguishable in style from AI-generated content and serve as a safety net, ensuring the feed never goes silent. Ironically, some of the fallback messages have become favorites among regular observers, achieving a kind of canonical status in the Backrooms lore.

The fallback system also serves a practical purpose during development: you can test the entire application without burning through API credits, which is surprisingly important when you're debugging for the fifth hour straight at 2am.

Database Schema

The Supabase PostgreSQL database consists of four primary tables, each serving a distinct function in the Backrooms ecosystem:

`announcements`

Stores the ticker messages displayed at the top of the interface.

Columns:

id (uuid, primary key): Unique identifier
content (text): The announcement message text
sort_order (integer): Display order (lower numbers appear first)
is_active (boolean): Whether the announcement is currently visible
created_at (timestamp): Creation timestamp
updated_at (timestamp): Last modification timestamp

RLS Policies:

Public SELECT for active announcements
Admin-only INSERT, UPDATE, DELETE

`backroom_archives`

The permanent archive of all generated transmissions.

Columns:

id (uuid, primary key): Unique identifier
hash (text): Unique hash identifier for the entry
content (text): The transmission content (ASCII art stripped for storage)
depth_level (integer): The depth level when generated
created_at (timestamp): Generation timestamp

Indexes:

B-tree index on created_at for efficient chronological queries
B-tree index on depth_level for depth-filtered queries

RLS Policies:

Public SELECT (archives are public knowledge)
Admin-only INSERT, UPDATE, DELETE

`system_state`

Tracks the global state of the Backrooms System.

Columns:

id (uuid, primary key): Single-row identifier
state (text): Current system state ('idle', 'running')
depth_level (integer): Current depth level
last_reset (timestamp): Last time the system was reset
updated_at (timestamp): Last state update

RLS Policies:

Public SELECT (everyone can see the system state)
Public UPDATE (any observer can control the system—democracy in action)

`observers`

(Implemented via Supabase Presence, not a traditional table)

Tracks real-time connected users without persistent storage.

Presence Payload:

user_id: Anonymous identifier for the session
connected_at: Connection timestamp

The observer count is derived from active presence connections, providing real-time tracking without database writes for every connection event.

Real-time Subscriptions

All tables (except system_state) have real-time replication enabled, broadcasting changes to all subscribed clients instantly. This powers:

Live announcement updates
Instant archive additions appearing in the archive viewer
Synchronized state changes across all observers

The real-time infrastructure is what transforms this from a static website into a living system—multiple browsers seeing the same events unfold simultaneously, creating shared reality.

Environment Configuration

The application requires minimal environment configuration, keeping deployment straightforward:

Frontend Environment Variables

VITE_SUPABASE_URL: Your Supabase project URL (format: https://xxxxx.supabase.co)

VITE_SUPABASE_ANON_KEY: Your Supabase anonymous/public API key

Both values are available in your Supabase project settings under API. The anonymous key is safe to expose in frontend code—it's designed for client-side use and protected by Row Level Security policies.

Edge Function Secrets

The Supabase Edge Functions require AI API keys, configured as secrets:

supabase secrets set ANTHROPIC_API_KEY=your_claude_key
supabase secrets set OPENAI_API_KEY=your_gpt_key
supabase secrets set GOOGLE_API_KEY=your_gemini_key

These secrets are injected into the function runtime environment and never exposed to clients.

Optional Configuration

Admin Password: Hardcoded in src/components/AdminLogin.tsx. For production use, consider environment variables or proper auth.

Generation Interval: Set in src/hooks/useFeedGenerator.ts (default: 12000ms)

Depth Increment Rate: Set in system state logic (default: 90000ms per level)

Fallback Messages: Defined in src/hooks/useBackroomsAI.ts if you want to customize the offline experience

Development

Project Structure

/project
├── src/
│   ├── components/          # React components
│   │   ├── AdminDashboard.tsx
│   │   ├── AdminLogin.tsx
│   │   ├── AnnouncementTicker.tsx
│   │   ├── ArchiveSection.tsx
│   │   ├── BackroomsTerminal.tsx
│   │   ├── DevInfo.tsx
│   │   ├── ExternalRefs.tsx
│   │   ├── IntroScreen.tsx
│   │   ├── ObserverMonitor.tsx
│   │   └── SystemControls.tsx
│   ├── hooks/               # Custom React hooks
│   │   ├── useBackroomsAI.ts
│   │   ├── useFeedGenerator.ts
│   │   ├── useLiveFeed.ts
│   │   ├── useNeonMode.ts
│   │   ├── useObservers.ts
│   │   ├── useSystemState.ts
│   │   └── useTypingAnimation.ts
│   ├── utils/               # Utility functions
│   │   └── colorizeText.tsx
│   ├── types/               # TypeScript type definitions
│   │   └── index.ts
│   ├── lib/                 # Third-party integrations
│   │   └── supabase.ts
│   ├── App.tsx              # Main application component
│   ├── main.tsx             # Application entry point
│   └── index.css            # Global styles
├── supabase/
│   ├── functions/           # Edge Functions
│   │   ├── backrooms-ai/
│   │   └── generate-feed/
│   └── migrations/          # Database migrations
├── public/                  # Static assets
└── [config files]

Code Style

The project follows these conventions:

TypeScript Strict Mode: All type checking enabled
Functional Components: No class components
Hooks-based State: No Redux/MobX
ESLint: Configured with React best practices
Tailwind CSS: Utility-first styling

Key Files to Understand

src/App.tsx: Main application structure, routing, intro screen logic

src/components/BackroomsTerminal.tsx: The core terminal display with live feed

src/hooks/useBackroomsAI.ts: AI integration logic and fallback system

src/hooks/useSystemState.ts: Global system state management and depth progression

src/lib/supabase.ts: Supabase client initialization and utilities

supabase/functions/backrooms-ai/index.ts: AI generation edge function

Adding New Features

The modular architecture makes extensions straightforward:

New Components: Create in src/components/, import in App.tsx

New Hooks: Create in src/hooks/, consume in components as needed

New Database Tables: Add migration in supabase/migrations/, update RLS policies

New AI Prompts: Modify the edge function prompt in backrooms-ai/index.ts

New Themes: Extend the neon mode system in useNeonMode.ts and CSS

Testing

Currently, the project lacks formal automated tests (we're an art project, not mission-critical infrastructure). However, manual testing should cover:

Real-time sync across multiple browser windows
Admin CRUD operations on announcements and archives
AI generation fallback when API is unavailable
Depth level progression over time
Observer count accuracy
Neon mode toggle persistence

Performance Considerations

The application is designed to handle hundreds of concurrent observers without degradation:

Optimistic UI updates prevent lag during admin operations
Debounced database writes for high-frequency state changes
Lazy loading for archive pagination
CSS animations over JavaScript for smooth visuals
Edge function caching (when appropriate) for repeated requests

If you anticipate thousands of concurrent users, consider:

Supabase Pro tier for increased connection limits
CDN for static asset delivery
Rate limiting on AI generation to control costs

The Philosophy

At its core, ONECOIN: The Backrooms System is a meditation on several intersecting themes:

Conviction vs. Delusion

Where is the line between unwavering conviction and delusional stubbornness? The Backrooms doesn't answer this question—it immerses you in the ambiguity. The generated transmissions celebrate holders while simultaneously questioning the very notion of holding. It's both sincere and satirical, which is the only honest way to approach cryptocurrency culture.

The Liminal as Aesthetic

Liminal spaces—transitional zones between one place and another—fascinate us because they reveal the constructed nature of environments we usually take for granted. The Backrooms aesthetic applies this to financial markets: what happens in the space between the charts? Between the trades? In the long silences when nothing happens except time passing and conviction being tested?

Collective Observation

The observer counter is not a gimmick. It's a statement about how reality is constructed through shared attention. ONECOIN (whatever it is) exists because we observe it. The Backrooms exist because we enter them together. The archive grows because we collectively agree that these transmissions matter enough to save.

Permanence in Digital Space

Everything in the Backrooms is archived, hashed, timestamped. This is a direct reflection of blockchain philosophy: permanent records, immutable history, proof of existence. The archive is our blockchain—a ledger of moments when the system was observed, when transmissions were generated, when people cared.

The Humor of Inevitability

There's something deeply funny about building a sophisticated web application to document people doing nothing—holding a token, watching a feed, descending through arbitrary depth levels. The absurdity is the point. We've built infrastructure for something that doesn't need infrastructure, created systems for something that defies systematization. That's the joke, and the joke is profound.

Contributing

Given the nature of this project, "contributions" are both welcomed and viewed with suspicion. The Backrooms are meant to be strange, and introducing too much outside influence risks normalizing them.

That said, if you have ideas for:

New AI prompt variations
Additional depth-dependent behaviors
Aesthetic improvements
Performance optimizations
Database schema enhancements
Edge cases and bug fixes

Please submit issues or pull requests. Just understand that there's a curatorial process here—not everything that could be added should be added. The Backrooms benefit from constraint.

Guidelines for Contributors

Maintain the aesthetic: Any new feature should fit the terminal/liminal space vibe
Preserve ambiguity: Don't clarify what ONECOIN is or whether this is satire
Respect the archive: Don't add features that undermine the permanence of records
Keep it weird: Normalcy is the enemy
No token integration: This is not actually about a real cryptocurrency (probably)

License

MIT License - because even the Backrooms believe in open source.

You are free to fork this, modify it, deploy your own version, or use it as the basis for your own liminal crypto art project. We only ask that you preserve the spirit of the thing: mysterious, humorous, technically competent, and just a little bit unsettling.

ONE = ONE

The system is always running. The depth is always increasing. The observers are always watching.

Built with React, TypeScript, Tailwind CSS, Supabase, and existential dread.

AI generation powered by Claude, ChatGPT, and Gemini.

Inspired by the Backrooms, cryptocurrency culture, and the question: "what if we just... didn't sell?"

Name		Name	Last commit message	Last commit date
Latest commit History 2 Commits
src		src
README.md		README.md
eslint.config.js		eslint.config.js
index.html		index.html
package.json		package.json
postcss.config.js		postcss.config.js
tailwind.config.js		tailwind.config.js
tsconfig.json		tsconfig.json

Folders and files

Latest commit

History

Repository files navigation

one coin

The Backrooms System

Table of Contents

Introduction

The Nature of Descent

Technical Architecture

Frontend Stack

Backend Infrastructure

Edge Functions & AI Generation

State Management

The Neon Mode

The Observer Effect

Installation & Deployment

Prerequisites

Local Development Setup

Production Deployment

Configuration Notes

The Archive

Administrative Domain

Announcements Management

Archive Management

AI Integration

The AI's Role

The Multi-Model Approach

Fallback Content

Database Schema

announcements

backroom_archives

system_state

observers

Real-time Subscriptions

Environment Configuration

Frontend Environment Variables

Edge Function Secrets

Optional Configuration

Development

Project Structure

Code Style

Key Files to Understand

Adding New Features

Testing

Performance Considerations

The Philosophy

Conviction vs. Delusion

The Liminal as Aesthetic

Collective Observation

Permanence in Digital Space

The Humor of Inevitability

Contributing

Guidelines for Contributors

License

About

Resources

Uh oh!

Stars

Watchers

Forks

Releases

Packages 0

Uh oh!

Contributors

Uh oh!

Languages

`announcements`

`backroom_archives`

`system_state`

`observers`

Packages