Angular walkthroughs: libraries, working code, and build vs. buy.
Angular's walkthrough ecosystem is the thinnest of the big three frameworks — mostly wrappers and framework-agnostic libraries. That's fine: here's what actually works, with code, plus what every library leaves you to build and when buying honestly wins.
Libraries and licenses checked August 21, 2026.
Searching for Angular tour libraries returns a thinner aisle than React's or even Vue's — a few maintained wrappers, several abandoned ones, and the framework-agnostic stalwarts. The good news buried in that: because the strongest options work at the DOM level anyway, Angular teams lose almost nothing to the ecosystem gap.
The standing caveat applies with extra force here: the library is the visible fifth of an onboarding system, and with fewer ecosystem batteries included, Angular teams end up hand-building even more of the targeting, persistence, and analytics layer than their React counterparts. The roundup first; that accounting after.
The libraries, honestly — with the code.
angular-shepherd — the maintained Angular wrapper
- License:
- MIT
- Best for:
- Angular teams that want Shepherd's power with service-based ergonomics
The official-adjacent Angular wrapper around Shepherd.js: a ShepherdService you inject, configure, and start from component lifecycle hooks. You get Shepherd's full capability — modal overlays, rich step options, transition hooks — in Angular idiom.
It inherits Shepherd's verbosity and styling homework, and as a wrapper it trails the core library's releases slightly. Both are livable; check the repo's cadence against your Angular version before committing.
import { Component, inject, OnInit } from "@angular/core";
import { ShepherdService } from "angular-shepherd";
@Component({ selector: "app-onboarding", template: "" })
export class OnboardingComponent implements OnInit {
private shepherd = inject(ShepherdService);
ngOnInit() {
this.shepherd.defaultStepOptions = { scrollTo: true };
this.shepherd.modal = true;
this.shepherd.addSteps([
{
id: "create-project",
text: "Everything starts here — create your first project.",
attachTo: { element: ".new-project-btn", on: "bottom" },
buttons: [{ text: "Next", type: "next" }],
},
]);
this.shepherd.start();
}
}ngx-ui-tour — the Angular-native option
- License:
- MIT
- Best for:
- Teams that want router-aware tours declared in templates
The most Angular-native choice: tour anchors declared as directives in your templates, with router integration so multi-route tours can navigate between pages as steps advance — a genuinely useful trick the DOM-level libraries make you wire yourself.
It's a smaller community than Shepherd's, with variants per UI kit (Material, console, plain). Scope your pick to the maintained variant matching your stack, and pin versions across Angular majors.
// Template: anchor steps with the tourAnchor directive
// <button tourAnchor="create.project" class="new-project-btn">New project</button>
import { Component, inject, OnInit } from "@angular/core";
import { TourService } from "ngx-ui-tour-md-menu";
@Component({ selector: "app-root", templateUrl: "./app.component.html" })
export class AppComponent implements OnInit {
private tour = inject(TourService);
ngOnInit() {
this.tour.initialize([
{ anchorId: "create.project", content: "Everything starts here.", title: "Create a project" },
{ anchorId: "invite.team", content: "Invite a teammate early.", title: "Bring the team" },
]);
this.tour.start();
}
}Driver.js — the lightweight one
- License:
- MIT
- Best for:
- Simple highlight-and-explain tours with minimal footprint
No Angular wrapper needed or wanted: import it in a component, call it from ngOnInit or a button handler, done. Dependency-free and tiny, with an API that fits in your head.
Minimal by design — for a two-step feature highlight it's ideal; for lifecycle-heavy multi-route tours you'll feel the ceiling and reach for Shepherd or ngx-ui-tour.
import { driver } from "driver.js";
import "driver.js/dist/driver.css";
const tour = driver({
showProgress: true,
steps: [
{
element: ".new-project-btn",
popover: { title: "Start here", description: "Create your first project." },
},
{
element: ".invite-field",
popover: { title: "Bring the team", description: "Invite a teammate early." },
},
],
});
tour.drive(); // e.g. from ngOnInit
Intro.js — the famous one, with a licensing trap
- License:
- AGPL-3.0, or a paid commercial license
- Best for:
- Open-source projects, or teams that buy the commercial license
The best-known name in the category, with an ngx-intro.js wrapper available — and AGPL-3.0 licensed, which for proprietary SaaS effectively means buying its paid commercial license. Almost no commercial legal team accepts AGPL obligations for a closed product.
Fine software, honest price — the trap is only in not reading the license until the security-and-legal review. Check first, or use the MIT options above.
import introJs from "intro.js";
import "intro.js/introjs.css";
introJs()
.setOptions({
steps: [
{ element: document.querySelector(".new-project-btn"), intro: "Everything starts here." },
{ element: document.querySelector(".invite-field"), intro: "Invite a teammate early." },
],
})
.start();What every library leaves you to build.
The tour is the visible fifth of an onboarding system. These four builds are the rest — and they are where hand-rolled setups quietly stall.
Who edits the copy?
Every library above makes a step's wording an engineering change — merge request, review, deploy. The activation owner files a ticket and waits, which is the dependency this tooling category exists to delete.
Targeting is a second project
New users only, role-aware flows, re-showing to non-finishers — audiences, traits, and rules are yours to build, and typically outweigh the tour code itself.
Seen-state is a third one
Per-user, cross-device "has seen" state needs your backend, an API, and a lifetime of maintenance. localStorage is a demo, not a system.
Analytics is a fourth
Step drop-off, funnels, and activation impact — libraries emit events at most; the measurement layer that answers the real questions is a separate build.
The whole trade, in one table.
| Dimension | Build on a library | Buy (Wakeline) |
|---|---|---|
| Upfront cost | Free (library) + engineering days to integrate | Free tier, then $49/mo for 25,000 MAU |
| Who edits a step's copy | An engineer, via a pull request and a deploy | Anyone on the team, in a visual builder, live in seconds |
| Targeting & segmentation | You build it — user traits, rules, audiences | Included: audiences, trait rules, saved segments |
| Analytics | You build it — step events, funnels, dashboards | Included: per-step funnels, trends, click actions |
| Seen-state & persistence | You build it — per user, across devices | Included, cross-device for identified users |
| Surfaces beyond tours | Checklists, surveys, banners: all separate builds | Included in the same builder |
| A/B testing | You build it, including the statistics | Included, with significance testing |
| Ongoing maintenance | Yours — selector breakage, library upgrades, edge cases | Vendor's — anchors degrade gracefully, tooling maintained |
Wakeline with Angular: deliberately boring.
Wakeline is the buy side, and the Angular story is deliberately boring: no Angular module, no wrapper, no build integration. The snippet operates on the rendered DOM — the level every Angular version ultimately produces — so standalone components, zoneless apps, and whatever v-next changes are all non-events.
- Anchors survive change detection. Steps attach by selector to the live DOM; re-renders don't detach them, and steps wait for conditionally-rendered elements or skip gracefully.
- Router transitions handled. Client-side navigation works, and steps can pin to URL paths with wildcards so a tour never fires on a lookalike route.
- Tours are built visually on your live app, no-code — and for admin panels behind a login, the browser extension builds right on your signed-in pages.
- The system gaps come filled: targeting and segments, cross-device seen-state, per-step funnels, A/B testing, plus checklists, surveys, and banners from one builder.
<script>
(function (w, d, s) {
w.Wakeline = w.Wakeline || function () { (w.Wakeline.q = w.Wakeline.q || []).push(arguments); };
var js = d.createElement("script"); js.async = 1; js.src = s;
var f = d.getElementsByTagName("script")[0]; f.parentNode.insertBefore(js, f);
})(window, document, "https://wakeline.io/wakeline.js");
Wakeline("init", { key: "YOUR_PUBLISHABLE_KEY" });
// After login — unlocks targeting, segments, and cross-device state:
Wakeline("identify", user.id, { name: user.name, plan: user.plan });
</script>When building on a library is still right.
One static tour, engineer-owned
A single internal-tool walkthrough written once fits Driver.js or angular-shepherd fine — no program means the system gaps never bite.
Your users are developers
Dev-tool audiences respect a hand-rolled tour, and an Angular shop can genuinely maintain one.
Zero budget, genuinely
The MIT options are free forever. (So is a 1,000-MAU free tier — price the engineering hours honestly before choosing.)
Multi-route tours with deep router coupling
If the tour must drive complex router navigation as a first-class feature, ngx-ui-tour's router integration is a real advantage worth building on.
What is the best walkthrough library for Angular?
angular-shepherd for capability in Angular idiom, ngx-ui-tour for template-declared anchors with router integration, Driver.js for minimal highlights — all MIT. Intro.js is well-known but AGPL; commercial use realistically means its paid license.
Does Wakeline have an Angular module or SDK?
Deliberately not — the snippet works at the DOM level every Angular version renders to. Standalone components, zoneless change detection, and version upgrades don't touch it: paste the snippet, call identify() after login, build visually.
Do walkthroughs survive Angular's change detection and routing?
Yes — anchoring is by selector against the live DOM, with steps waiting for elements to appear (or skipping gracefully). Router navigation is handled, and URL pinning with wildcards keeps multi-route tours from mis-firing.
Our Angular app is an internal tool behind SSO — can we still build tours?
That's the browser-extension case: it opens Wakeline's builder on your signed-in pages, so login-gated admin panels — where Angular lives disproportionately — get the same point-and-click authoring as public apps. Published tours then run for every user via the snippet.
When should an Angular team build instead of buy?
One engineer-owned tour: build, probably on Driver.js or angular-shepherd. An onboarding program with targeting, funnels, and non-engineer editing: the build-vs-buy table is the honest accounting — the library is the cheap fifth, the system around it is the build.
Ship a Angular tour today — without the build.
The snippet takes five minutes; the free plan covers 1,000 monthly active users. Compare it against the library route on your own app.