Langy is a revolutionary, open-source platform for navigating, comparing, and understanding the complex world of technology. It moves beyond simple lists and articles, providing a structured, multi-dimensional interface to explore the intricate relationships between programming languages, libraries, frameworks, and applications.
At its core, Langy is not just a database of information; it is a dynamic engine for knowledge discovery. It empowers developers, architects, and learners to make informed decisions by visualizing technology through multiple analytical "lenses" and navigating the vast ecosystem based on deep, semantic relationships.
Langy is built on three foundational principles that work together to create a unique and powerful user experience.
All technologies, or TechObject
s, exist within a four-dimensional space:
This represents the "stack" of technology, from foundational to applied.
Every TechObject
is a container for its entire version history, allowing for precise, granular analysis.
TechObject
→ Major Version
→ Minor Version
→ Patch Version
(e.g., Python → 3.x → 3.12 → 3.12.1)
Instead of static pages, Langy uses six dynamic "lenses" to analyze any collection of TechObject
s. The user can switch between these viewers at any time to gain different insights from the same set of data.
DEPENDS_ON
, EXTENDS_BY
, IMPLEMENTS
).SHARES_PARADIGM
, MENTAL_MODEL_CLASH
).SAME_RUNTIME
, PERFORMANCE_FASTER
).SAME_DOMAIN
, INTEGRATION_FRIENDLY
).LEARNING_EASIER
, DOCUMENTATION_BETTER
).This is Langy's most powerful feature. Navigation is not just about clicking links; it's about asking questions.
LEARNING_EASIER
and share the SAME_RUNTIME
.TechObject
s can be sliced and diced using a type-safe filtering engine. Users can construct complex queries that span all six viewer dimensions, such as: "Show me all Programming Languages created after 2010 that have an 'ALIGNED_DESIGN_PHILOSOPHY' with Rust."Langy is engineered for scalability, maintainability, and platform independence using a clean, three-layered architecture.
/src ├── 🏛️ core/ # The Brain: Domain Logic & Use Cases (Platform-Agnostic) ├── 🖼️ interfaces/ # The Blueprint: UI & Adapters Contracts (Platform-Agnostic) └── 🚀 platforms/ # The Body: Concrete Implementations (Web, Desktop, Mobile)
core
: This is the heart of the application. Written in pure, dependency-free TypeScript, it contains all the business logic, entities, value objects, and use cases. It knows what the application does but has no knowledge of how it will be displayed. This guarantees that the core logic can be reused across any platform.
interfaces
: This is the universal contract layer. It defines the abstract "blueprints" for every piece of the user interface (BaseCard
, BaseViewer
), the state management system (stores
, actions
), and the platform-level adapters (BaseStorageAdapter
, BaseNavigationAdapter
). It ensures that every platform implementation will have a consistent structure and behavior.
platforms
: This is where the concrete implementations live. A web
sub-directory might contain a React or Svelte project that implements the contracts from interfaces
using web technologies. A desktop
directory could do the same using Electron. This clean separation allows Langy to be deployed anywhere without changing a single line of the core
logic.
FilterCriterion
(/core/domain/value-objects/Filter.ts
), a type-safe object that prevents invalid filters./core/application/use-cases
) orchestrates the request, using Services (/core/domain/services
) like the FilterService
./core/domain/entities/TechObject.ts
), which hold the rich viewersData
.interfaces
layer and stored in a Store (/interfaces/common/components/state/stores
)./interfaces/common/components/state/selectors
) computes the derived state needed by the UI.platforms
implementation renders the data provided by the selector.Let's trace a typical interaction to see how the architecture comes to life:
/levels/1
(Programming Languages). The RouteHandler
(/interfaces/common/components/routing
) detects the change and mounts the LevelPage
.LevelPage.onMount()
method is called, which dispatches the techObjectActions.fetchTechObjectsForLevel(1)
action.core
to fetch the data, which is then placed into the techObjectStore
.ContentPane
layout component is subscribed to the selectVisibleTechObjects
selector.ContentPane
receives the new list and renders it as a grid of TechObjectCard
components.ToolsBar
.navigationActions.changeViewerMode('temporal')
, updating the uiStore
.ContentPane
's render logic now sees the new viewer mode. Instead of rendering cards, it instantiates and renders the TimelineViewer
component. The viewer gets its specific data from the selectActiveViewerData
selector, which automatically extracts the temporal
data from the visible objects. The change is instantaneous and efficient.Langy is a long-term project with a vision to become the definitive tool for understanding technology ecosystems.
/platforms/web/react
, bringing the common
interfaces to life in a fully functional web application.ITechObjectRepository
that connects to a real database (e.g., Firebase, PostgreSQL) to persist and serve the TechObject
data.viewerData
for all TechObject
s, making Langy a living, breathing knowledge base.core
services and can help users construct complex filters, explain relationships, and summarize viewer data in natural language.desktop
app using Electron or a mobile
app, reusing the exact same core
and interfaces
layers.Langy is an ambitious project, and contributions are welcome. The best way to start is by:
react
platform in /platforms/web/react
.viewerData
for your favorite technologies into JSON files that can later be imported into the database.(Detailed contribution guidelines will be added soon.)