Lepiter: A Moldable Knowledge Management System for the Age of Programmable Documents

In the landscape of knowledge management tools, most applications force users into rigid, predefined structures. You write notes in one tool, code in another, and documentation in a third. Lepiter, developed by the feenk company as part of the Glamorous Toolkit (GT) ecosystem, breaks this paradigm by offering something fundamentally different: a moldable development environment where knowledge management becomes an interactive, programmable experience.

Glamorous Toolkit

Glamorous Toolkit is the Moldable Development Environment.

What Makes Lepiter Different

Lepiter isn’t just another note-taking app with code blocks. It’s built on the Pharo Smalltalk environment, which means every aspect of the system is live, inspectable, and modifiable. When you write a snippet of code in Lepiter, you’re not embedding static text that gets executed elsewhere — you’re creating living objects that can be inspected, visualized, and transformed right within your knowledge base.

The core innovation lies in its page model. Each Lepiter page contains a sequence of “snippets” — blocks that can contain text, code, visualizations, or custom views. Unlike traditional notebooks, these snippets are first-class objects in the system. You can query them, transform them, and build tools that operate on your knowledge graph programmatically.

The Philosophy of Moldable Development

The Glamorous Toolkit team, led by Tudor Gîrba, advocates for “moldable development” — the idea that your tools should adapt to your problems rather than forcing your problems into the tool’s constraints. Lepiter embodies this philosophy completely.

Consider a typical scenario: you’re documenting a complex API, collecting examples, and building up understanding over time. In a traditional system, you’d write markdown files, maybe embed some code examples, and hope your documentation stays synchronized with reality. In Lepiter, you can:

Write executable code that queries your actual system

Create custom visualizations that update as your code changes

Build domain-specific views tailored to your problem space

Link between concepts bidirectionally and semantically

The system doesn’t just store knowledge — it helps you shape it into the form most useful for your thinking.

Knowledge as a Graph, Not a Hierarchy

While many knowledge management systems impose hierarchical structures or rely purely on flat collections with tags, Lepiter treats knowledge as a genuine graph. Pages link to other pages, but more importantly, you can navigate these connections through custom views and queries.

The explicit links database in Lepiter tracks relationships between pages, enabling sophisticated navigation patterns. You can ask questions like “show me all pages that reference this concept but haven’t been updated in the last month” or “visualize the cluster of pages around this technical problem.” This goes beyond simple backlinks — it’s a foundation for building semantic relationships into your knowledge base.

Living Documentation

One of Lepiter’s most powerful features emerges from its integration with the GT environment: your documentation can contain live views of your system. When documenting a class hierarchy, you don’t just write about it — you embed an interactive view that shows the actual current state of your code.

This has profound implications for technical knowledge management. Documentation drift, where docs become outdated as code changes, becomes detectable. You can create views that flag inconsistencies, highlight missing documentation, or show coverage gaps. Your knowledge management system becomes a development tool, and your development environment becomes a knowledge management system.

Collaborative Potential and Version Control

Lepiter databases are stored as files on disk, making them compatible with standard version control systems like Git. Each page is a separate file, and the format is designed to be merge-friendly. This means teams can collaborate on knowledge bases using the same workflows they use for code.

The potential for collaborative, version-controlled knowledge management in a live environment opens interesting possibilities. Imagine code reviews that include both the code changes and the evolving documentation, all queryable and transformable. Or research teams building up shared understanding where every claim can be verified against live data.

Challenges and Considerations

Lepiter’s power comes with complexity. The learning curve is steep, particularly for those unfamiliar with Smalltalk or the GT environment. This isn’t a tool you’ll master in an afternoon. It requires investment in understanding not just how to use Lepiter, but how to think in terms of moldable development.

The Pharo ecosystem, while vibrant, is smaller than mainstream languages. This means fewer third-party integrations and a need to build more infrastructure yourself. However, for problems that require deep customization and live programming capabilities, this trade-off may be worthwhile.

Performance can be a consideration for very large knowledge bases, though the team continues to optimize the system. The image-based nature of Pharo means your entire environment lives in memory, which has both advantages (speed, live objects) and constraints (memory usage, initial load time).

Use Cases Where Lepiter Excels

Software Architecture Documentation: When you need to maintain living documentation that stays synchronized with evolving codebases, Lepiter’s ability to embed live views and executable examples is unmatched.

Research Notebooks: For researchers who need to combine theoretical notes with computational experiments, visualizations, and evolving analyses, Lepiter provides a unified environment where everything is queryable and transformable.

Domain Modeling: Building up understanding of complex domains benefits from Lepiter’s ability to create custom visualizations and domain-specific views. You’re not limited to text and diagrams — you can build interactive explorations of your domain.

Technical Learning: When learning complex systems, being able to run code, visualize structures, and build up understanding incrementally in a single environment accelerates comprehension.

The Future of Programmable Knowledge

Lepiter represents a different vision for knowledge management — one where the boundaries between documentation, code, and tooling dissolve. It’s not trying to be a universal tool for everyone, but rather a powerful environment for those whose work involves complex reasoning, system understanding, and the need to shape their tools to their problems.

As knowledge work becomes increasingly computational and as the lines between writing, coding, and analysis blur, systems like Lepiter point toward a future where knowledge management isn’t about storing information in static forms, but about creating living environments where understanding can grow, evolve, and remain connected to the systems it describes.

For developers, researchers, and technical thinkers willing to invest in learning its paradigm, Lepiter offers something rare: a knowledge management system that’s as programmable and malleable as the knowledge it contains.

Lepiter is open source and available as part of Glamorous Toolkit at gtoolkit.com. The system continues to evolve with active development from the feenk team and a growing community of users exploring moldable development.