By ByteBot
Tunnelto, an open-source Rust-based tunneling tool, exploded to trending #3 on GitHub on December 27, 2025, gaining 565 stars in a single day. The tool does exactly what ngrok does—expose your local web server via a public URL—but it’s free, open-source, and self-hostable. For developers tired of ngrok’s 2-hour session limits, forced interstitial warning pages, and $8-29/month pricing tiers, Tunnelto offers something better: a tool that works the way developers actually want to work.
When a utility tool gains 565 stars in 24 hours, it’s not hype. It’s frustration finding a solution.
The Problem Every Web Developer Hits
You’re building a Stripe integration. Stripe sends webhook events to your server when payments complete, subscriptions renew, or customers dispute charges. Those webhooks need a publicly accessible HTTPS URL. Your local development server runs on http://localhost:3000. That’s not publicly accessible.
The standard workaround: Deploy to staging after every code change, hope the webhook arrives, check logs, realize you forgot to parse the timestamp field correctly, redeploy, wait, repeat. Slow feedback loops kill momentum. Moreover, you can’t set breakpoints in deployed code. You can’t inspect payloads in real-time. You’re testing in staging with production data, which feels wrong and is occasionally catastrophic.
Tunneling tools solve this. Run your app locally on port 3000. The tunneling tool gives you https://random-subdomain.tool.dev that forwards traffic to your localhost. Stripe sends webhooks to the public URL. Your local server receives them. You debug with breakpoints, inspect payloads, iterate in seconds instead of minutes. It’s not a hack—it’s how webhook development should work.
However, the problem isn’t new. ngrok has solved it for years. But ngrok’s free tier restarts every 2 hours with a new random URL. That interstitial warning page shows up on every HTML request. When you hit the 1GB bandwidth cap, you’re done for the month. For features developers need daily—custom domains, unlimited sessions, no bandwidth caps—ngrok charges $8-29/month.
That pricing isn’t outrageous for infrastructure. But for a utility tool you use locally? It adds up to $96-348/year for something that feels like it should just work.
Tunnelto: The ngrok Alternative That Just Works
Tunnelto is what ngrok would be if ngrok were built by developers who cared more about solving problems than extracting recurring revenue. Install it via Homebrew or Cargo. Run tunnelto --port 8000. You get a public URL forwarding to your localhost. No session limits. No interstitial pages. No bandwidth caps (if you self-host). No vendor lock-in. Furthermore, it’s MIT licensed. Inspect the code. Fork it. Host your own server. Or use the hosted service at tunnelto.dev.
The GitHub repository has 3,665 stars and 202 forks. Created by GitHub user agrinman, the project has 119 commits across 5 contributors and 16 releases. The latest (v0.1.18) shipped in May 2021, which is either a stability signal or a maintenance concern depending on whether you see software as something that should constantly change or something that works and needs no fixing.
The Rust implementation matters. It’s built on tokio’s async-IO for high-performance networking. Single static binary distribution means no runtime dependencies. No “install Node.js first” friction. Download, run, done. Performance matters for tunneling—latency affects webhook delivery, demo responsiveness, and mobile testing. In contrast to JavaScript alternatives, Rust delivers speed, memory safety, and modern tooling in one package.
Basic usage matches ngrok’s simplicity:
# Install
brew install agrinman/tap/tunnelto
# or
cargo install tunnelto
# Expose local port
tunnelto --port 8000
# Your site is live at https://random-subdomain.tunnelto.dev
# Custom subdomain
tunnelto --port 3000 --subdomain mycustomname
# https://mycustomname.tunnelto.dev
For self-hosting, deploy the tunnelto_server via Docker. The official tunnelto.dev service uses fly.io’s Private Networking for distributed coordination across multiple instances. Self-hosted setups lack that centralized coordination—clients must connect to the same server instance—but for individual use or small teams, that’s fine.
Why Developers Choose Open Source Over SaaS
When VS Code launched, it was free, open-source, and backed by Microsoft. Atom (GitHub/Microsoft) and Sublime Text (commercial, paid) lost market share. Prettier and ESLint replaced commercial formatters and linters. Ruff (Rust-based Python linter) is replacing Pylint and Flake8. The pattern is clear: For local developer tools, open source wins.
The reasons aren’t just about cost:
Trust. You can inspect Tunnelto’s code. You can verify it’s not logging your webhook payloads or leaking your localhost traffic. With ngrok, you trust their privacy policy and infrastructure. That’s fine for many use cases, but when you’re testing payment webhooks or handling PII, trust matters.
Control. Self-hosting means no service outages from a third-party provider. No surprise pricing changes. No feature deprecations because the vendor pivoted to enterprise. You own the infrastructure. If Tunnelto development stops tomorrow, you can fork it and maintain it yourself.
Values. Developers increasingly value transparency, autonomy, and community over convenience and vendor relationships. Open source aligns with those values. It’s not anti-commercial—plenty of developers happily pay for GitHub, Vercel, or Datadog—but for tools that run locally and solve simple problems, OSS feels right.
That said, ngrok isn’t losing its entire market to Tunnelto.
ngrok’s enterprise features—SSO, RBAC, compliance certifications, SLAs—matter to large organizations. Managed services eliminate operational overhead. When your team has 50 developers, paying $39/user/month for reliability and support makes sense. However, when you’re an individual developer testing webhooks on weekends, $8/month for a tunneling tool doesn’t.
Both can succeed. They’re solving different problems for different users.
Why Tunnelto is Trending on GitHub
Tunnelto isn’t new—the repository has existed since 2020. The Hacker News “Show HN” post from June 2020 positioned it as both a free hosted service and an open-source project. So why is it trending now, in December 2025?
Three possibilities:
1. Year-end tool exploration. Developers reflect on their tooling stack at year-end. “What should I use in 2026?” lists drive GitHub traffic. Tunnelto benefits from inclusion in “ngrok alternatives” content.
2. ngrok friction accumulation. Free tier limitations compound over time. The first 2-hour session restart is annoying. The 50th is infuriating. When enough developers hit that threshold, they search for alternatives.
3. Rust ecosystem growth. Rust usage continues expanding beyond systems programming. 2.26 million developers use Rust globally. 38% use it at work (up from 34% in 2024). Rust-based tools get discovered by an expanding audience.
Whatever the specific trigger, the trend validates that developers want tools like Tunnelto. OSS alternatives to commercial SaaS. Self-hosting options. No artificial limits. Transparent code. Rust performance and safety.
The broader trend is tunneling commoditization. What feels like a premium feature today (ngrok’s edge config, OAuth, webhook verification) will feel like table stakes tomorrow. Cloudflare might bundle tunneling into its developer platform. Vercel could integrate it into their CLI. GitHub Codespaces already has port forwarding built-in. When infrastructure platforms absorb a feature category, standalone tools either go upmarket (enterprise-only) or compete on values (OSS, privacy, control).
Tunnelto competes on values. That’s not a weakness—it’s a strategy. And for a growing segment of developers, it’s the right one.
When to Use Tunnelto vs ngrok
Use Tunnelto if:
- You value open source and want to inspect/audit code
- Session limits and interstitial pages break your workflow
- You prefer self-hosting for privacy or control
- You’re comfortable with Docker and basic infrastructure
- $8-29/month feels too expensive for a utility tool
Stick with ngrok if:
- You need enterprise features (SSO, RBAC, compliance)
- Managed services are worth paying for (no ops burden)
- You want commercial support and SLA guarantees
- You integrate with ngrok’s webhooks, OAuth, edge config
- You trust third-party infrastructure and prioritize convenience
There’s no wrong choice. It’s about priorities: cost vs convenience, control vs features, values vs reliability.
What matters is knowing the trade-offs exist and choosing intentionally instead of defaulting to the first tool everyone recommends.
Key Takeaways
- Tunnelto gained 565 GitHub stars in 24 hours, signaling strong developer demand for open-source ngrok alternatives that eliminate free tier limitations.
- Open source wins for local developer tools when trust, control, and transparency matter more than enterprise features and managed convenience.
- Tunneling is commoditizing—what feels premium today (custom domains, unlimited sessions) will become table stakes as platforms like Cloudflare and Vercel bundle it in.
- Choose based on priorities: Tunnelto if you value OSS, self-hosting, and no costs; ngrok if you need enterprise features, SLAs, and managed services.
