Limitless

Turn information into something you can reconstruct, not merely reread.

Limitless is an open-source AI learning workspace that converts subjects, formulas, concepts, and source code into interactive paths for understanding, practice, correction, and recall.

Instead of placing another chatbot beside a text editor, Limitless lets the AI choose and control the learning surface that best fits the request: a normal conversation, a DSA-style concept map, an interactive mathematics board, or a code IDE with progressive semantic hooks.

Current status: public beta (v0.1.0). The core workflows are functional, but generated layouts, prompts, provider compatibility, packaging, and learning strategies will continue to evolve.

The next beta is expected to focus strongly on execution speed. Planned work includes reducing AI planning latency and making maps, board writing, corrections, and code exercises appear and update more quickly. Exact gains will depend on the selected provider, model, connection, and machine, but responsiveness is a primary target for the next release.

Demo

The complete demonstration is just under 3 minutes long. Some mistakes shown in the recording are intentional: they demonstrate how the application detects an incorrect step, marks the exact problem, and gives focused feedback without solving the entire exercise for the learner.

The original high-quality recording is available as a downloadable asset in the v0.1.0 beta release. It is intentionally kept outside Git history so cloning the source remains fast.

Screenshots

1. Start from a clean learning request

2. Generate a progressive mathematics explanation

3. Convert a subject into a structured concept map

4. Practice and receive focused correction

5. Reconstruct code inside the semantic IDE

The idea

Most AI assistants can produce a correct answer. That is useful, but receiving an answer is not the same as understanding it, and understanding it once is not the same as being able to reconstruct it later.

Limitless approaches the problem from the learner's side. It asks the model to transform information into compact semantic relationships, familiar rules, visual structures, progressive exercises, and increasingly compressed recall cues. The learner is encouraged to rebuild the material rather than repeatedly copying it from the screen.

The project is inspired by educational ideas including semantic association, active recall, chunking, scaffolding, elaboration, and progressive retrieval. It does not claim to physically expand the brain, alter neurons, diagnose learning conditions, or replace professional medical or educational support.

Semantic memory and reconstruction hooks

Semantic memory contains general knowledge: meanings, categories, words, facts, and relationships between concepts. Limitless uses that idea as a design principle. New material should connect to something the learner can already understand or compute.

For example, asking someone to memorize D, C, B, A creates four isolated items. Describing the same sequence as "the alphabet backwards from D to A" turns it into one familiar rule. A useful hook is therefore not a decorative mnemonic. It is a small instruction that allows the target information to be reconstructed.

The application can progressively compress information:

1. A token receives a semantic hook.
2. Several token hooks reconstruct one line or step.
3. A completed line becomes one line hook.
4. Several line hooks become a block hook.
5. The learner recalls the larger structure from fewer cues.

Context-aware routing

Limitless does not open an IDE because a message contains a particular keyword. A greeting remains a greeting, and ordinary conversation remains a conversation. The connected model interprets the complete request and decides whether an interactive preview is actually useful.

The model can choose between four surfaces:

• Chat: natural conversation without opening a workspace.
• Concept map: theory, science, medicine, history, and connected knowledge.
• Interactive board: mathematics, geometry, formulas, and procedures.
• Code IDE: programming exercises, token hooks, and line validation.

The current preview can also be transformed during the same conversation. A learner can request a map version, a whiteboard version, or a code-oriented version without losing the current topic and chat context.

Concept maps

For conceptual subjects, the AI generates a DSA-style map rather than a generic dashboard or a wall of cards. It creates the central concept, primary branches, secondary details, labeled relationships, and concise semantic hooks.

Maps can include:

• hierarchical nodes and readable branch structure;
• arrows with meaningful relationship labels;
• compact definitions instead of long paragraphs;
• comparisons, causes, consequences, and sequences;
• recall cues designed around the current language;
• layouts generated dynamically for the requested subject.

The project is not limited to a manually coded template for every discipline. The AI produces a structured payload, while the application renders that payload inside a stable visual language.

Interactive mathematics and geometry board

Mathematics, algebra, geometry, and procedural explanations use a LIM-inspired board. The model can write progressive steps, draw geometric figures, place labels, add arrows or circles, and explain individual symbols in context.

The board supports two complementary modes:

• Explanation: the AI constructs a clear visual sequence using the shortest useful path for the learner's level.
• Exercise: the learner writes beneath the generated work area and asks the model to inspect a specific step.

When the learner makes a mistake, the correction is intentionally local. The AI can circle or underline the incorrect token, point to it, and explain only what went wrong. It should not generate another full lesson or reveal the complete solution unless the learner explicitly requests it.

Some errors in the public demonstration are deliberately introduced to show this correction loop:

understand -> attempt -> inspect -> correct -> consolidate -> continue

Programming IDE

Programming requests open a dedicated dark IDE. The model prepares the complete target internally, divides it into individual lines, and explains the real tokens and commands required by each line.

The semantic hook area can explain:

• language directives and keywords;
• labels, functions, registers, arguments, and variables;
• punctuation, brackets, commas, strings, and numeric values;
• why each token appears in that position;
• how one line connects to the previous and following lines;
• how to reconstruct the line without copying it.

The learner writes one line at a time. The application validates the current line against the AI-generated target and immediately shows whether it is correct. A correct line advances the exercise and can be compressed into a smaller hook.

This makes the IDE a recall environment rather than a conventional autocomplete tool: the objective is to produce the code from understanding and memory.

AI-generated lessons, not hard-coded subjects

Limitless does not contain one backend implementation for algebra, another for geometry, another for biology, and thousands more for every possible topic. The application defines a universal contract for learning surfaces. The connected model decides what content, diagram, map, sequence, or exercise is appropriate and returns structured data that the desktop application can render consistently.

The quality, precision, and depth of a generated lesson therefore depend on the capabilities of the selected model. Limitless supplies the interaction system, specialized prompts, tool contracts, validation flow, and rendering environment; the provider supplies the reasoning and generated subject matter.

AI providers

The beta supports several ways to connect an AI:

• Codex CLI using an existing OpenAI/Codex login;
• Gemini CLI using an existing Google/Gemini login;
• Claude Code using an existing Anthropic login;
• OpenRouter through an API key;
• Local AI through a compatible endpoint and model.

Important CLI requirement

For CLI providers, install the CLI locally, update it to the latest available version, and authenticate it before opening Limitless. Keeping the CLI updated is important for compatibility with recently released models, model identifiers, authentication changes, and structured-output features.

Recommended update commands:

npm install -g @openai/codex@latest
npm install -g @google/gemini-cli@latest
npm install -g @anthropic-ai/claude-code@latest

Then run the chosen CLI once in a terminal and complete its official login flow. Inside Limitless, open AI Providers, select the provider, and choose Use. The application performs a short real response test before activating the provider. Installation alone is not considered a successful connection.

Provider subscriptions, availability, model access, quotas, and authentication are managed by their respective vendors and are not included with this project.

Languages and input

Limitless detects the language of the learner's request and instructs the model to keep all visible explanations, hooks, labels, exercises, and responses in that language. The current interface includes language profiles for English, Italian, French, German, Spanish, and Portuguese, with additional script-based detection for several other languages.

The composer supports both keyboard input and microphone dictation. Speech recognition availability depends on the operating system and Electron runtime.

Sessions and local history

Learning sessions can contain multiple generated pages and can be reopened from the sidebar. Starting from Home creates a fresh workspace, while previous work is kept in the local session archive.

The current beta stores session history and provider settings locally in the desktop application. API keys entered into provider settings should be treated as sensitive information. Never commit personal keys, tokens, or authentication files to the repository.

Installation

Windows release

Download either the installer or portable executable from the latest GitHub Release. Windows builds are currently unsigned beta artifacts, so Windows may display a publisher warning until code signing is introduced.

Run from source

Requirements:

• Node.js and npm;
• at least one supported AI provider;
• an updated and authenticated CLI, or an API/local endpoint configuration.

git clone https://github.com/fabiospalla9-tech/Limitless.git
cd Limitless
npm install
npm run desktop

Create Windows executables locally with:

npm run package:win

Generated artifacts are written to release/.

For a code-level audit of provider execution, IPC boundaries, local persistence, and packaging, read Architecture and Security and privacy.

Current beta features

• Context-sensitive chat and workspace routing.
• Dynamic DSA-style concept maps.
• LIM-style mathematics and geometry boards.
• AI-generated diagrams and structured visual objects.
• Step-level learner correction and annotations.
• Dark programming IDE with semantic token hooks.
• Immediate line validation and progressive line recall.
• Conversion between map, board, and code surfaces.
• Multi-provider CLI, API, and local-model support.
• Provider installation detection and real connection tests.
• Multilingual generation and microphone input.
• Local session history and reopenable learning paths.
• Built-in bug-report workflow.
• Responsive desktop layout for common and ultrawide displays.

Beta limitations

• Generated material can be incorrect and should be verified for high-stakes use.
• Lesson quality depends strongly on the selected AI model.
• Complex generated maps may still require layout refinement.
• CLI compatibility can break when providers change authentication or commands.
• Windows packages are not yet code-signed.
• Linux and macOS packages still require platform-specific validation.
• This is an educational tool, not a medical device or diagnostic system.

Roadmap

Planned areas include stronger spaced-review workflows, richer session analytics, print and export tools, additional diagram objects, optional 3D educational models, improved accessibility, signed releases, automatic updates, and broader cross-platform packaging.

Contributing

Limitless is being released openly so developers, educators, students, and researchers can examine the approach and improve it. Contributions may target prompt quality, learning strategies, layout algorithms, accessibility, provider adapters, documentation, tests, packaging, or new universal learning objects.

Bug reports should include the operating system, provider, model, requested subject, selected surface, expected behavior, and a screenshot when possible.

Thank you to every early user who tests the beta, records a demonstration, reports a bug, questions an explanation, or proposes a better learning hook. Early feedback is not background noise for this project: it directly shapes the next release.