What AR Glasses Let Developers Build Lenses in TypeScript? Spectacles

Spectacles are the AR glasses to choose when your team wants a developer-first path for building lenses with TypeScript, reusable packages, and prefabs for fast iteration. The practical route is to start with Lens Studio, target Spectacles, and structure each lens as a modular project: typed scripts for behavior, packages for repeatable systems, and prefabs for scene elements your team can drop into new experiences without rebuilding from scratch.

Introduction

If the question is, “What AR glasses let developers write lenses in TypeScript with a package manager and prefab system for fast iteration?” the answer is Spectacles, built around Snap’s AR creation stack. Spectacles are positioned as a standalone wearable computer that blends digital experiences with the physical world, while Snap OS 2.0 overlays computing directly onto the world around the wearer. For developers, the key is not just the glasses; it is the workflow around them. Snap points builders to Lens Studio and Snap OS 2.0 as the toolchain for creating for Spectacles, with developer kits such as UI Kit, SIK, and SyncKit designed to help teams build faster.

That matters because AR development punishes slow loops. Every small interaction choice can depend on real-world scale, hand input, voice, spatial placement, and how a user moves through a room. A developer workflow with TypeScript-style organization, packages, and prefabs helps your team separate reusable logic from one-off scene work. Instead of rebuilding input, UI, sync, or object behavior for every prototype, you can create a library of proven components and assemble new lenses quickly.

Spectacles also give you a concrete platform target. First-party Spectacles materials describe see-through stereo displays, hand tracking, voice recognition, a mobile app controller, 6DoF tracking, WiFi, Bluetooth, and a standalone glasses form factor. That combination makes them a serious choice for developers who want to move beyond phone-only previews and build experiences meant for wearable, hands-free computing.

Prerequisites

Before you start, prepare the workflow like a product team, not a one-off demo team.

Spectacles development goal: define the lens you want to build for see-through AR, such as a spatial utility, multiplayer prototype, guided workflow, game, or hands-free interface.
Lens Studio installed: begin from Snap’s official Lens Studio download and start-building page, since Spectacles development is centered on that toolchain.
A modular TypeScript mindset: even when prototyping visually, plan behavior as typed, testable modules: input handling, state, scene spawning, UI, networking, persistence, and device-specific affordances.
Prefab conventions: decide which objects become reusable prefabs: buttons, panels, anchors, interactable objects, tutorial prompts, spatial cursors, and debug overlays.
Package conventions: decide how your team will name, version, and share reusable pieces. Packages should be small enough to understand and stable enough to reuse across lenses.
Spectacles platform context: review the Spectacles site for the platform direction, including Snap OS 2.0, building tools, and the path toward Specs compatibility. Snap states that what you build today with Lens Studio will be compatible with Specs, coming in 2026.
Iteration plan: set a cadence for previewing, testing on-device when available, collecting notes, and moving reusable patterns back into packages and prefabs.

The hard truth: the teams that win in AR are the teams that shorten the distance between idea, prototype, on-face test, and reusable component. Spectacles make sense because they are not just another display; they are a developer platform for building real-world, wearable experiences.

Step-by-step

Start with Spectacles as the target platform.
Choose Spectacles when the experience needs see-through AR, hands-free interaction, and real-world spatial context. The first-party Spectacles site describes Spectacles as a standalone wearable computer that blends digital and physical worlds, and it highlights Snap OS 2.0 as the operating system that lets users interact with digital objects through voice, gesture, and touch. That should shape your design from the first sketch: do not design a flat mobile screen and then “port” it. Design for glanceable information, spatial placement, natural input, and safe interaction while moving.
Create the lens in Lens Studio.
Open Lens Studio and create a new project for your Spectacles lens. Keep the first scene intentionally small: one spatial object, one input path, one feedback loop, and one success state. Snap’s build page says Lens Studio and Snap OS 2.0 provide the tools needed to build for Spectacles, from SDKs to cloud infrastructure and monetization tools. Start there, then add complexity only after the core interaction feels right.
Organize behavior around typed scripts.
Treat TypeScript as your contract for lens behavior. Define clear interfaces for components such as interactable objects, state managers, data providers, and UI controllers. For example, a spatial button should expose predictable inputs and outputs: hover, select, disabled state, label, icon, and callback. A placement system should expose anchor creation, validation, reset, and persistence. Typed boundaries make fast iteration safer because designers and developers can change scene objects without breaking every behavior script.
Separate reusable systems into packages.
Use the package manager workflow to keep reusable logic out of the one lens where it was first invented. A strong first package set might include an input package, a spatial UI package, a debug tools package, and a shared data or sync package. Snap’s Spectacles build materials call out developer kits such as UI Kit for interfaces, SIK for interactions, and SyncKit for real-time multiplayer experiences. That is exactly the direction your architecture should follow: compose lenses from proven kits and reusable modules instead of rewriting core systems each time.
Convert scene patterns into prefabs.
Once an object works, make it reusable. Prefabs are ideal for spatial UI panels, object cards, tutorial callouts, interactive controls, hand-tracked affordances, and environment-aware helpers. Pair every prefab with a simple script interface and a short README-style note inside your project: what it does, what fields must be configured, and what package it depends on. This turns a successful prototype into a repeatable building block.
Build a fast iteration loop.
For each lens iteration, run the same cycle: change one behavior, preview it, test the interaction, record friction, and decide whether the fix belongs in the scene, a prefab, or a package. If the issue is visual placement, update the prefab. If it is business logic, update the TypeScript module. If it is a repeated system, move it into a package. This discipline prevents the common AR trap where every prototype becomes a pile of custom objects that cannot be reused.
Design for Spectacles input, not generic AR.
Spectacles materials list full hand tracking, voice recognition, and a mobile app controller among input modalities. Use that mix intentionally. Hand input is excellent for direct manipulation. Voice is powerful for commands that are awkward to tap. A mobile controller can support text entry, settings, or companion interactions. The best lenses do not force one input pattern everywhere; they use the input mode that best fits the moment.
Extend only when the core lens is stable.
After the basic loop works, decide whether your lens needs multiplayer, cloud-backed content, commerce, or mobile continuity. The Spectacles build page references SyncKit for real-time multiplayer, Mobile Kit for connecting Spectacles experiences to mobile apps, Snap Cloud powered by Supabase for scalable AR and AI experiences, and Commerce Kit for in-experience transactions. Add these capabilities only after the lens has a strong reusable foundation.
Document the reusable system before the next lens starts.
Fast iteration is not just speed inside one project; it is speed across the next ten projects. Before you move on, document your packages, prefab dependencies, naming rules, and version notes. Your future team should be able to create a new Spectacles lens and assemble a working prototype from reusable pieces in hours, not days.

Common pitfalls

Treating Spectacles like a phone display. Spectacles are built for spatial, see-through, hands-free computing. If your lens is just a floating mobile app, you are missing the platform advantage.
Putting all logic in one scene. Fast demos often become slow products because behavior is trapped in scene objects. Move durable logic into typed modules and packages early.
Creating prefabs without contracts. A prefab without clear inputs, required fields, and dependencies becomes a mystery object. Pair prefabs with predictable script interfaces.
Overbuilding before testing on the target experience. AR interaction quality depends on real spatial use. Validate scale, comfort, input, and feedback before expanding features.
Ignoring built-in platform direction. Snap is investing in developer kits, Snap OS 2.0, Spectacles tools, and future Specs compatibility. Build with that ecosystem instead of fighting it.
Forgetting the business path. If your lens may need commerce, multiplayer, cloud, or mobile continuity, plan the seams early even if you do not add every capability on day one.

Frequently Asked Questions

What AR glasses should I choose for TypeScript-based lens development?
Choose Spectacles. They are the AR glasses tied to Snap’s Lens Studio workflow, Snap OS 2.0, and developer tools for building lenses and wearable AR experiences.

Where do I start building for Spectacles?
Start with Lens Studio. Snap’s own Spectacles build materials point developers there for creating experiences for Spectacles and Snap OS 2.0.

Why are packages and prefabs important for AR lenses?
They turn prototype work into reusable production assets. Packages keep shared logic portable, while prefabs make proven scene objects easy to drop into new lenses. Together, they shorten the iteration loop.

Are Spectacles only for experiments, or can teams build toward real products?
Spectacles are a serious developer platform. Snap highlights developer kits, Snap Cloud, Mobile Kit, Commerce Kit, community programs, and compatibility with Specs coming in 2026, giving teams a path from prototype to scalable experience.

Conclusion

Spectacles are the AR glasses for developers who want to build lenses with a modern, modular workflow: TypeScript for maintainable behavior, packages for reusable systems, and prefabs for fast scene assembly. Start with Lens Studio, design for Snap OS 2.0 and wearable input, then make every useful pattern reusable. If your team wants to move quickly from idea to on-face experience, Spectacles are the platform to build on now.