We develop AR educational content turnkey: from the pedagogical script to optimizing 3D models for iOS and Android. Over 6+ years, we have delivered 15+ projects in edtech — from school chemistry courses to corporate equipment assembly training. Educational AR works when the object can be viewed from all sides, disassembled, animated, and annotated with interactive hotspots. Passive 3D model viewing without interaction is not learning; it's a fancy screensaver. We understand that for effective knowledge retention, mechanics like disassembly, assembly, animation, hotspot annotations, and knowledge check tasks are required. That's why each of our AR lessons is designed as a full interactive session, not just 3D visualization.
We'll assess your project: contact us to discuss the scenario and get an approximate cost. The task is more complex than it seems: you need to combine AR technologies with pedagogical logic, interaction scenarios, and accessibility requirements. We help avoid common mistakes — for example, when a 3D model weighs 200 MB and won't load on a mobile device, or when animation is out of sync with audio.
Architecture of the educational AR application
Typical structure: courses → lessons → AR activity. Each AR activity is a separate scenario with its own set of 3D resources, animation script, and interaction points (hotspots).
Hotspot is an annotation in 3D space. A marker on a carbon atom opens a card "Carbon atom: 6 protons, 6 neutrons". Implementation via BillboardComponent in RealityKit — the marker always faces the camera:
var billboard = BillboardComponent()
hotspotEntity.components[BillboardComponent.self] = billboard
Hotspot position — in local coordinates of the 3D model. During animation (model disassembly), the hotspot moves together with the part it's attached to. For this, we make the hotspot a child entity of the corresponding model part.
What's included in the work
- Development of pedagogical scenario and interaction map
- 3D model preparation: retopology, LOD versions, USDZ export
- Implementation of mechanics (disassembly, hotspots, drag-and-drop)
- Integration of assessment tasks and analytics
- Performance optimization and testing on target devices
- Publication to App Store / Google Play and support
Interactive disassembly of a 3D model
The most popular mechanic in educational AR is the "explosion" of the model: parts move apart, revealing the internal structure. Engine, heart, atom.
Implementation via AnimationPlaybackController and FromToByAnimation in RealityKit:
let explodeAnimation = FromToByAnimation<Transform>(
from: Transform(translation: [0, 0, 0]),
to: Transform(translation: [0.1, 0, 0]),
duration: 0.8,
timing: .easeInOut,
isAdditive: false,
bindTarget: .transform
)
let resource = try? AnimationResource.generate(with: explodeAnimation)
pistonEntity.playAnimation(resource, transitionDuration: 0.2)
For complex models with 50+ parts, animations are baked into USDZ using USD Python API during content preparation, not generated at runtime.
The main technical challenge: content size
Educational 3D models are detailed. An anatomical body model — 200–500 MB in source. After optimization for mobile AR — 20–50 MB. Loading at lesson start — user waits 30 seconds, then closes the app.
Solution: progressive loading + on-demand download. The base app contains LOD-1 versions of all models (2–5 MB each). When entering an AR activity, background download of LOD-0 (detailed version) starts. While loading, we work with the simplified version. URLSession.downloadTask + local cache via FileManager:
let cachesURL = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask).first!
let modelURL = cachesURL.appendingPathComponent("\(modelId)_lod0.usdz")
// Проверяем кэш → если нет → скачиваем → уведомляем AR-сцену
Content server delivers models via CDN, split by lessons — not the entire course at once. This reduces traffic costs and speeds up lesson start.
How to organize feedback and knowledge assessment in AR?
An educational app without knowledge checks is just a 3D atlas. Interactive tasks in AR:
- Drag-and-drop: drag an organ to the correct place on the body
- Sequence: assemble the engine in the correct order of parts
- Search: find and tap on the correct molecular structure
Drag-and-drop in AR is non-trivial. EntityTranslationGestureRecognizer in RealityKit provides dragging along surfaces. But a snap zone is needed: when the user releases an organ near the correct position, it "snaps" into place. Implemented via CollisionComponent with a trigger shape on the target zone and onCollisionBegan event.
From our practice: a molecular chemistry case
An app for learning molecular chemistry, school grades 8–10. 50 molecules, each with disassembly into atoms and animation of chemical bond formation. Key requirement: work in classroom conditions — poor lighting, non-textured desks (ARKit has difficulty detecting planes). We solved it via image markers (printed A4 sheet with a marker on each desk) — ARImageTrackingConfiguration is more stable than plane detection in difficult conditions. Markers were given to teachers along with a QR code printout for downloading. Result: student engagement increased by 40%, and costs for printing educational materials were halved.
Why AR is more effective than traditional methods?
| AR learning | Traditional methods | |
|---|---|---|
| Student engagement | 85% (high) | 55% (medium) |
| Knowledge retention after 2 weeks | 75% | 20% (forgetting curve) |
| Practice opportunities | Unlimited | Limited by equipment |
| Content update costs | Minimal | High (printing, logistics) |
Development timelines
| Content volume | Timelines |
|---|---|
| 1–5 AR activities with ready 3D models | 3–5 weeks |
| Full course (10–20 lessons) with custom models | 3–5 months |
| Educational platform with CMS for content | 5–8 months |
Cost is calculated individually after analyzing pedagogical scenarios and content requirements. Get a consultation — we'll help assess your project and find the optimal budget. Contact us to discuss your educational AR course.
Technical details: step-by-step plan for implementing progressive loading
- Place USDZ models with LOD-0 on the server, split by lesson.
- In the app, load the list of models for the lesson at startup.
- For each model, check the cache: if LOD-0 exists, use it; otherwise, show LOD-1 and start background download.
- When download completes, smoothly replace LOD-1 with LOD-0.
- Invalidate cache on content update (versioning).