Wakeline
wakeline for angular

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 open-source options

The libraries, honestly — with the code.

angular-shepherdthe 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();
  }
}
angular-shepherd: Shepherd's engine behind an injectable service.

ngx-ui-tourthe 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();
  }
}
ngx-ui-tour: anchors as directives, steps against anchor ids.

Driver.jsthe 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
Driver.js: identical in Angular, Vue, or anything else — that's the point.

Intro.jsthe 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();
Intro.js quick start — read the license before this ships to production.
the honest accounting

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.

build vs. buy

The whole trade, in one table.

DimensionBuild on a libraryBuy (Wakeline)
Upfront costFree (library) + engineering days to integrateFree tier, then $49/mo for 25,000 MAU
Who edits a step's copyAn engineer, via a pull request and a deployAnyone on the team, in a visual builder, live in seconds
Targeting & segmentationYou build it — user traits, rules, audiencesIncluded: audiences, trait rules, saved segments
AnalyticsYou build it — step events, funnels, dashboardsIncluded: per-step funnels, trends, click actions
Seen-state & persistenceYou build it — per user, across devicesIncluded, cross-device for identified users
Surfaces beyond toursChecklists, surveys, banners: all separate buildsIncluded in the same builder
A/B testingYou build it, including the statisticsIncluded, with significance testing
Ongoing maintenanceYours — selector breakage, library upgrades, edge casesVendor's — anchors degrade gracefully, tooling maintained
the buy side

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>
The entire integration, for any Angular app. There is no step two.
honest limits

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.

questions

Angular onboarding tours: common questions.

Still stuck? Read the docs or talk to us.

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.