# Stackryze FreeDomains: claim a free subdomain and point it at your own hosting

> Stackryze FreeDomains is a frontend for a free managed subdomain service on .indevs.in, .sryze.cc, .ryzedns.org and .nx.kg. It is a Vite single-page app you can self-host, but the domains themselves come from a hosted backend the repository does not include.

**stackryze/FreeDomains** — Project brief: Stackryze Domains: Free Domain for Everyone, Claim yours today. Claim a domain and point it to any hosting provider or your own infrastructure.

- Repository: https://github.com/stackryze/FreeDomains
- Website: https://domain.stackryze.com
- Stars: 12,238 · Forks: 262
- Language: JavaScript
- License: AGPL-3.0
- Published: 2026-08-04 · Updated: 2026-08-18 · Language: en
- Canonical page: https://hysenlabs.com/projects/stackryze-freedomains

## What Stackryze FreeDomains actually gives you

The README describes Stackryze Domains as a free managed subdomain service for developers, students, and open-source communities. That wording is precise: you get a name under a namespace Stackryze controls, not a registration you own at a registry. Four extensions are listed, .indevs.in, .sryze.cc, .ryzedns.org and .nx.kg, with the note that more extensions are coming.

The pitch is that you can point the name at any hosting provider or your own infrastructure. That is the ordinary DNS deal. You take the subdomain, then create a CNAME or A record wherever your DNS is managed, or hand the nameservers over if the service supports it. Nothing here is exotic, and that is the point. The value is that the namespace already exists and the delegation is free, so a student with no card and no budget can still put a project on a real hostname instead of a platform subdomain.

The audience is narrow and stated plainly: students, developers, and OSS projects. If you are running a business that needs invoices, an SLA, or a support contract, this is not the service for you, and the README never claims otherwise.

## The frontend is open, the domain backend is not

The repository is a Vite single-page application. package.json names it @indevs/frontend, marks it private, and lists dev, build, lint and preview scripts, plus a deploy script that runs npx wrangler deploy. The dependency list is a React and Radix UI stack, with @hcaptcha/react-hcaptcha and @marsidev/react-turnstile present for bot protection, axios for HTTP, and Tailwind wired in through @tailwindcss/vite. The top-level entries confirm the shape: index.html, vite.config.js, src/, public/, and a wrangler.toml for Cloudflare.

What that means in practice is that the code you can read and modify is the claim form and the dashboard shell. The part that allocates a subdomain, writes the DNS record, and serves the zone is not in this repository. The README points to https://domain.stackryze.com as the dashboard, and the .env.example refers to the base URL of the FreeDomains backend API, which tells you an API exists on the other side of the form and that it is not shipped here.

So self-hosting this project gives you your own copy of the interface. It does not give you your own domain service. Anyone reading the AGPL-3.0 licence and expecting a complete, forkable registrar has misread the repository layout, and the README does not correct that impression anywhere.

## Running the dashboard locally with Docker or Vite

The repository includes a two-stage Dockerfile. The builder stage uses node:22-alpine, sets NPM_CONFIG_LEGACY_PEER_DEPS=true, runs npm ci, and takes VITE_API_URL as a build argument before running npm run build. The runner stage installs serve globally and runs the built dist directory on port 3000. Because Vite inlines environment variables at build time, the API URL has to be present during the build, not at container start; passing it later will not change the bundle.

For local development, copy the environment template and fill it in. The .env.example documents two keys:

```bash
# Copy to .env for local dev; set these as build-time env vars in the
# Cloudflare Pages project settings for deployments.
VITE_API_URL=http://localhost:5000
VITE_TURNSTILE_SITE_KEY=
```

With that file in place, the standard Vite loop applies. The scripts in package.json are the ones you run:

```bash
npm install
npm run dev
npm run build
npm run preview
```

npm run dev starts the Vite dev server and serves the SPA. npm run build produces dist/, and npm run preview serves that build locally so you can check it before deploying. The deploy script removes .wrangler/deploy and then calls npx wrangler deploy, which is the Cloudflare path the wrangler.toml is there for.

One caveat on the first real use: the form is protected by hCaptcha and Cloudflare Turnstile, and VITE_TURNSTILE_SITE_KEY is empty in the template. A local instance with an empty site key will render the form but the claim flow depends on the backend and the captcha configuration, neither of which the repository provides. Expect to point VITE_API_URL at the hosted API rather than a local one.

## Nameserver geography and what it does not promise

The README publishes three nameservers: ns1.stackryze.com in New York City, ns2.stackryze.com in Nuremberg, and ns3.stackryze.com in Hyderabad. Publishing the topology is a reasonable transparency gesture and it tells you the zones are anycast-ish in intent, spread across three continents.

It does not tell you the query volume those servers carry, whether the zones are signed with DNSSEC, or what the record TTLs are. None of that appears in the README. If you are evaluating this for anything where resolution latency or DNSSEC validation matters, those are open questions you would have to measure yourself against the live service.

The more consequential gap is tenure. The README says you get full ownership and complete control, which is true of the DNS records you create and not true of the domain itself. The registrant of indevs.in, sryze.cc, ryzedns.org or nx.kg is Stackryze or whoever holds those names, and a subdomain delegated to you can be revoked, repriced, or lost if the parent registration lapses. The README does not document a revocation policy, a retention guarantee, or a migration path off the namespace. That silence is the single biggest thing to weigh before you put a production service on one of these names.

## When a free subdomain is the wrong choice

The failure mode is not technical, it is administrative. A subdomain under a namespace you do not control is fine for a portfolio, a class assignment, a hackathon demo, or a documentation site. It is a poor fit for anything where the hostname is part of your identity or your users' trust.

Email is the clearest case. The README lists four domain extensions and says nothing about MX records, mailbox provisioning, or SPF and DKIM delegation. If you need mail on the domain, assume you cannot get it here and plan around that. A custom domain for a business, where customers type the address and expect it to still work in three years, has the same problem in a slower form.

There is also a captcha dependency baked into the claim path. hCaptcha and Turnstile are both in the dependency list, and Turnstile requires a site key that the template leaves blank. If your environment blocks those scripts, or you are claiming from a network the captcha vendor treats as suspicious, the form is the part that breaks.

Finally, the repository is not archived, and no last push date is recorded in the repository information available here, so there is no way to state how recently the code moved. Treat the project's activity level as unverified rather than assumed.

## How this differs from DuckDNS and from paid registration

DuckDNS is the closest well-known comparison: a free dynamic DNS service that hands out subdomains under duckdns.org and lets you update an A record through a token-based HTTP endpoint. The difference in approach is that DuckDNS is built around programmatic updates and a stable API for dynamic IPs, while Stackryze FreeDomains is built around a browser dashboard with a captcha in front of the claim form. If your use case is a home server whose IP changes, DuckDNS is the better-shaped tool. If your use case is a static site or a student project that needs a name once and a CNAME to a host, the dashboard model is fine.

The other comparison is simply buying a domain. A registered domain under .com or .dev costs money annually but gives you a registrant record, transfer rights, and email. The README's own framing, free managed domains with no lock-in, is honest about which side of that trade you are on: no lock-in on the DNS records, but no ownership of the name either. Those are different things and the marketing line blurs them.

For open-source projects specifically, the practical alternative is a project subdomain offered by a hosting platform, or a GitHub Pages URL. Both are uglier. Both are also less likely to disappear because a volunteer stopped paying for a registration.

## Licence and the cost of staying current

The repository is AGPL-3.0. That is a strong copyleft licence with a network clause: if you modify the frontend and run it as a network service for other people, the AGPL expects you to offer those users the corresponding source. For a self-hosted personal dashboard, that obligation rarely bites. For anyone planning to fork the interface and run a competing claim service, it very much does. This is a description of the licence text, not legal advice; if you are building a business on a fork, talk to a lawyer.

The upgrade cost is the interesting part. Because the frontend is a static bundle built with Vite, updating it means rebuilding and redeploying, and the Dockerfile rebuilds from package-lock.json with npm ci. The dependency tree is large, dominated by individual Radix UI packages, so a lockfile refresh will produce a lot of version churn for very little user-visible change. There are no releases listed, which means there is no changelog to read before you pull. You would be tracking the main branch directly.

The operational cost that matters more is not in this repository at all. The API, the DNS zone, and the nameservers are run by Stackryze. A frontend upgrade cannot fix a backend outage, and the README points to https://status.stackryze.com for live status rather than describing any failover you could configure yourself.

## Conclusion

Adopt Stackryze FreeDomains if you need a working subdomain for a student project, a demo, or an open-source landing page and you accept that the namespace belongs to someone else. Do not adopt it if you need email on the domain, a contractual guarantee of tenure, or a backend you can run yourself: the repository ships only the frontend, and the DNS is served by ns1.stackryze.com in New York City, ns2.stackryze.com in Nuremberg and ns3.stackryze.com in Hyderabad. Before you point anything important at it, claim one subdomain, add a CNAME at your host, and watch it resolve through a full DNS propagation cycle.

## FAQ

### Can I get a domain for free with Stackryze FreeDomains?

Yes, in the sense the README describes: Stackryze Domains is a free managed subdomain service, and you claim a name under .indevs.in, .sryze.cc, .ryzedns.org or .nx.kg through the dashboard at domain.stackryze.com. You get control of the DNS records, not ownership of the domain itself.

### Do free domains still exist?

Stackryze FreeDomains is one that does, offering four extensions as of the README. The trade is that the namespace belongs to the operator, and the README does not document a retention guarantee or a revocation policy for claimed subdomains.

### What is FreeDomains?

It is the repository behind Stackryze Domains, a Vite and React single-page application that serves as the claim and dashboard interface for free managed subdomains. The domain allocation backend is not part of the repository; the .env.example points to a separate API via VITE_API_URL.

### Is Stackryze FreeDomains legit?

The repository publishes its frontend source under AGPL-3.0 and its nameservers as ns1.stackryze.com in New York City, ns2.stackryze.com in Nuremberg and ns3.stackryze.com in Hyderabad, with a status page at status.stackryze.com and an abuse contact at reportabuse@stackryze.com. Whether that is enough for your use case is a judgement the repository cannot make for you.

### Can I register a domain by myself with Stackryze FreeDomains?

No. The README describes a managed subdomain service, so you claim a name under one of the four listed extensions rather than registering a domain at a registry. The registrant of the parent domains is not you, and the README does not describe any transfer or ownership path.

### What is the cheapest way to get a domain?

Stackryze FreeDomains is free rather than cheap: the README states that the service removes cost and complexity, and the four extensions listed carry no stated fee. The trade is that the name sits under a namespace Stackryze controls, and the README does not document a retention guarantee.

## Sources

- [Official documentation](https://domain.stackryze.com)
- [Official README](https://github.com/stackryze/FreeDomains#readme)
- [Project repository](https://github.com/stackryze/FreeDomains)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/stackryze-freedomains