One login. Your software.

Simple, like
computers
used to be.

Give your team one way into the tools they use. Passwords and passkeys. Clear access controls. Source code you can own and run yourself.

Free MIT source. Optional setup help. No per-seat Auth license.

AUTH.EXE — Your workspace

One account.
The right doors.

Access chosen by your owner.

Example product permissions

ShareAccess granted
ViewAccess granted
TasksNot assigned

Sign in once. Each connected product checks whether you belong.

Passwords + passkeysInvite only

Product illustration. Example permissions, not a live account.

Built for the
Nate’s Software family

A useful front door

Let people get to work.
Keep control of who gets in.

For a small team with several connected apps, sign-in should be understandable. Auth brings identity, product permissions, and security activity into one place.

01 / SIGN IN

A password first.
A passkey when you’re ready.

Start with your email and password. Save a passkey for your device, phone, or security key when it suits you. Existing passkeys work directly. No email sign-in links.

02 / CHOOSE ACCESS

Your team.
Your guest list.

The organization owner invites members and grants individual products. A valid account doesn’t open every door. Revoke a member’s access when their work is done.

03 / SEE ACTIVITY

Know what happened.
Know where to look.

The owner’s security log records sign-in and access events, outcomes, and available network details. Filter recent activity and inspect individual requests without exposing passwords or tokens.

One identity.
Separate applications.

Connected products use the shared Auth hub and keep their own application data. Your team signs in through a common front door; each product still decides what the person can do inside.

How it works

Invite. Sign in.
Get on with it.

A deliberate setup process, followed by fewer interruptions for the people using your software.

Open organization admin →
  1. The owner opens the right doors.

    Add a member and choose their products. Create an invite code and share it through a channel you trust.

  2. The member makes it their account.

    Set a password, sign in, and optionally save a passkey. Most products are invite-only. A few, like GitForge, let anyone create a free account.

  3. The apps check access.

    Connected products verify the shared identity and product grant. The owner can review activity and change access from the same administration area.

Your front door.
Your copy of the software.

Auth is MIT-licensed. Read the source, adapt it, and run your own instance. You don’t need to buy a license from Nate to use the code commercially. Paying for help is a separate choice.

Get Auth

Choose the help you need.

Use the existing workspace, build your own, or bring Nate in to help with the setup. Choose the source, the shared workspace, or a clearly scoped project.

01 — Nate’s Software

Free sign-in

For invited Nate’s Software members

Use the shared login across connected Nate’s Software products.

  • Password and passkey sign-in
  • One organization identity
  • Access granted by the owner
Sign in to your workspace
02 — Run it yourself

Free source

MIT license · your infrastructure

Take the code and make it part of your own software.

  • Read, modify, and use commercially
  • Deploy on your own domain
  • Manage your own updates and operations
Get the source code ↗
03 — A hand with setup

Talk to Nate

A scoped, one-time engagement

Get help installing Auth and connecting the apps your team uses.

  • Agree on integrations and deliverables
  • Define handoff and support in advance
  • Get a quote before committing
Discuss your setup →

Self-hosting has ongoing infrastructure costs, including your domain and hosting. A one-time setup fee does not include unlimited future maintenance or support. Scope, price, and any support period are agreed with Nate before work begins.

An honest fit check

Built for connected apps.
Know the boundaries before you buy.

Auth is a working first-party sign-in system for Nate’s Software. It is not a drop-in replacement for a broad enterprise identity suite.

Available today

A focused set of controls

  • Email and password sign-in, plus optional WebAuthn passkeys.
  • Owner-managed invitations and individual product grants.
  • Shared sign-in for products integrated with the Auth hub.
  • Owner-only security activity, including available IP addresses and request details.
  • Recent activity view covering 30 days, with automatic cleanup of older records.
Check your requirements

Integration is a real project

  • The hub uses a custom first-party SSO integration. OIDC, SAML, and SCIM are not supported protocols today.
  • There is no enterprise SLA or claim of independent security certification.
  • Third-party directory sync and a broad catalog of prebuilt connectors are not included.
  • Additional standards and enterprise controls require separate work. Don’t plan around an unannounced delivery date.
  • Passkey availability depends on the browser, device, and secure deployment configuration.

For regulated environments or enterprise procurement, review the source and your security requirements before choosing a deployment. Review your deployment requirements with Nate before committing.

For the person wiring it up

The hood opens.

The repository contains the auth core, shared hub, client integration, and UI packages. Inspect the implementation before you choose it.

The current hub includes Nate’s organization and owner configuration; adapting it for another organization requires source changes and review. Running your own instance also means configuring your domain, secrets, storage, and connected apps. You’re also responsible for backups, updates, and operational monitoring.

AUTH — Source files
packages/coreAuthentication primitives and storage interfaces.
packages/hubShared sign-in, administration, and product access.
packages/clientConnect an application to the hub.
packages/uiUI examples and styling hooks.
Source availableMIT licensed

Before you decide

Good questions.
Plain answers.

The important details shouldn’t need a sales call to uncover.

Why pay if the code is free?

You’re paying for work: setup, application integration, configuration, and an agreed handoff or support period. The MIT source remains free. You can do the work yourself or hire someone else.

Does “free sign-in” include every Nate’s Software product?

No. Authentication is free for invited users. Product access is granted separately by the organization owner, and individual software products may have their own terms.

Can I replace Okta or another enterprise provider?

Only after comparing your actual requirements. Auth currently serves first-party connected applications with a custom SSO flow. It does not provide OIDC, SAML, SCIM, a large connector catalog, or an enterprise SLA. If you need those today, this is not a ready replacement.

What happens if someone loses a passkey?

A member who has set up a password can still sign in with it. This is not a promise of recovery from every lockout: confirm your recovery and support procedures before putting a deployment into service.

What does the security log tell me?

The owner can inspect recent authentication and access activity, outcomes, verified account identities when available, and network details such as IP addresses. Claimed identities and browser-reported issues are labeled separately. Network location is approximate; it is not proof of a person’s physical location.

What will it cost to operate my own instance?

Your hosting, domain, and any operational services are your responsibility. Costs depend on your deployment and usage. A setup quote covers the agreed work, not an unlimited hosting or maintenance commitment.

How do support and future features work?

Discuss support scope and response expectations directly with Nate. There is no standard enterprise SLA advertised here. Additional integrations or controls need a separate agreement; roadmap ideas are not current capabilities or promised delivery dates.

Software you can understand

A front door that belongs
with your software.

Start with the source. Bring your requirements. Get a clear answer about what fits and what needs work.