By peter_lzh Plenty of education products talk about “personalized learning.” But when you try to make it real, you hit a very concrete question: how does the system know exactly where a child is stuck?
If a child struggles with fractions, the problem may not be fractions themselves — it may be that they haven’t yet grasped that “a whole can be split into equal parts.” If a child writes poor sentences, it may not be weak expression, but not yet understanding the difference between a complete sentence and a fragment.
So what an education system really needs isn’t just an AI teacher that can explain things — it also needs a learning map. That’s exactly what Marble’s open-source os-taxonomy provides.
What Is os-taxonomy
The formal name of os-taxonomy is the Marble Skill Taxonomy, an open learning-taxonomy dataset released by Marble.
It breaks primary and elementary learning content into fine-grained micro-topics, then connects them with prerequisite dependencies that capture which topics must come before others.
The current version is v1, and its core data includes:
- 1,590 micro-topics
- 3,221 prerequisite dependencies
- 8 subjects
- 3,261 curriculum standards
- 183 domain clusters
It is not an app and not a model, but a set of structured education data you can read, analyze, and build on directly.
Key Features
The project’s core value is turning course content from a “flat list” into a “learning graph.” Ordinary curriculum standards usually tell you what to learn, but rarely what to learn first, what counts as mastery, or how knowledge points connect. The Marble Skill Taxonomy does three extra things.
First, it breaks content into teachable micro-topics. For example, the README cites “Building sentences,” which sits under English / Grammar & Punctuation, for ages 4 to 6. It doesn’t just say a child should understand sentences — it spells out evidence of mastery, such as being able to distinguish a complete sentence from a fragment and to write a complete sentence with a subject and a verb.
Second, it links prerequisite relationships between topics. For instance, a topic about volume and vibration depends on a child first understanding that vibration produces sound. That dependency is recorded in dependencies.json, complete with a hard or soft strength marker and a reason.
Third, it aligns with formal curriculum standards. Micro-topics link to frameworks such as NGSS, Common Core, and the UK National Curriculum, so the dataset offers both fine-grained learning paths and alignment with official curricula.
Who Should Look at It
The most compelling thing about os-taxonomy isn’t that it open-sourced a pile of education data — it’s that it decomposes “learning something” into nodes, evidence, and paths.
If you work on AI education, course recommendation, learning-path planning, or education knowledge graphs, this project is worth studying. It isn’t the answer itself, but it makes an excellent underlying map. It also suggests a new product shape for education founders.
Data Structure
The core data lives in the data/ directory as UTF-8 JSON. The main files include:
data/topics.json— micro-topics, i.e. the nodes in the graphdata/dependencies.json— prerequisite links, i.e. the edgesdata/curriculum-standards.json— sources of curriculum standardsdata/clusters.json— domain summaries written for parentsdata/manifest.json— counts, checksums, and other metadata
The project also ships a schema/ directory that describes the data structure with JSON Schema.
If you view it as a graph, topics.json is the node table and dependencies.json is the edge table. Developers can index by topic id, then query which prerequisites a knowledge point depends on, or reverse-query which later topics it unlocks.
Put simply, it isn’t a syllabus — it’s a structural map of “how a child learns something, step by step.”
How to Use It
This project is a pure dataset, so no traditional installation is needed. You can clone the repo directly:
git clone https://github.com/withmarbleapp/os-taxonomy.git
cd os-taxonomyThen run the validation script:
node scripts/validate.mjsIn JavaScript you can read the JSON directly:
import topics from './data/topics.json' with { type: 'json' };
import deps from './data/dependencies.json' with { type: 'json' };
const byId = new Map(topics.topics.map(t => [t.id, t]));
const prereqs = deps.dependencies
.filter(d => d.topicId === 'mt_N8CpN1EJrP')
.map(d => byId.get(d.prerequisiteId).name);Good use cases include:
- Knowledge-point localization for AI tutors
- Personalized learning-path recommendation
- Education knowledge-graph visualization
- Curriculum design and competency breakdown
- Education-content grounding for RAG systems
- Student knowledge-gap analysis
Things to Keep in Mind
This project is not a complete AI education product. It does not provide student-mastery data and has not released semantic embeddings. The team explicitly notes that per-child / user data is not published.
The licensing also deserves a careful read. The database structure uses ODbL 1.0, while Marble’s own text content uses CC BY-SA 4.0. curriculum-standards.json contains third-party curriculum standards under different licenses depending on source — some are codes-only and do not include the original standard text.
If you plan to use it in a commercial product, read
README.md,LICENSE,LICENSE-CONTENT, andPROVENANCE.mdcarefully first.
Project Links
- GitHub: github.com/withmarbleapp/os-taxonomy
- Live visualization: withmarble.com/curriculum
- License: ODbL 1.0 and CC BY-SA 4.0; curriculum-standards portions follow upstream licensing.