Show HN за 1 августа 2025 г.

Hey HN,

I'm Brandon, a solo dev, and I built KubeForge - a visual editor for Kubernetes deployments that helps you build and validate YAML configs.

Origin Story: Over the past couple weeks, I got fed up manually writing Kubernetes YAMLs, especially when working with nested structures like containers, env, and volumeMounts. Even small typos or misaligned fields added lost time to broken deploys.

So I started hacking together a tool to visualize the structure of Kubernetes objects based on the OpenAPI schema. That prototype quickly turned into a full manifest builder.

What KubeForge does:

- Pulls the latest Kubernetes OpenAPI schema (auto-updated daily)

- Generates field-level forms with type safety, required fields, and smart defaults

- Lets you visually build manifests like a flow editor

- Outputs clean, deploy-ready YAML, with multi-object exports

Personally, I wanted a tool that:

- Validates fields as I build, not after deployment

- Surfaces nested fields, tooltips, and types without switching tabs

- Lets me export or share real YAMLs easily

Try it out:

GitHub: https://github.com/kubenote/KubeForge

Live demo: https://demo.kubefor.ge

Website: https://kubefor.ge

It’s free and open source. I’d love feedback, bug reports, or ideas. Contributions welcome too .

Thanks, Brandon

I started this project a couple of weeks ago because I was stuck on my side project and needed some motivation. For a very long time I wanted to get back to do something useful in lisp/scheme, did a quick research and settled on CHICKEN mostly because it's relatively well maintained, fast enough, it's extremely easy to build/install and very easy to write interop to pretty much any library.

Most of the projects that I've written on the side have been using some combination of Sinatra + Sequel + Postgres/Redis/Something else + HTMX. I love the simplicity of Sinatra's API so I decided to focus on trying to have a similar experience but in scheme, trying to make it ergonomic for a scheme dev (that part might not be there yet since I'm not an experienced scheme dev).

The most fun part was the dev cycle: Emacs + NREPL + Aider (as a code reviewer & rubber ducky. For codegen it's mostly annoying but works great for documentation & refactoring).

I hope to add full SSE & WebSocket support some time this week. Anyway, hopefully this is interesting to some of you and might be a source of fun :)

Hi HN,

We’re Alex and Kalan, the creators of Pontoon (https://github.com/pontoon-data/Pontoon). Pontoon is an open-source data export platform that makes it really easy to create data syncs and send data to your enterprise customers. Check out our demo here: https://app.storylane.io/share/onova7c23ai6 or try it out with docker: https://pontoon-data.github.io/Pontoon/getting-started/quick...

While at our prior roles as data engineers, we’ve both felt the pain of data APIs. We either had to spend weeks building out data pipelines in house or spend a lot on ETL tools like Fivetran (https://www.fivetran.com/). However, there were a few companies that offered data syncs that would sync directly to our data warehouse (eg. Redshift, Snowflake, etc.), and when that was an option, we always chose it. This led us to wonder “Why don’t more companies offer data syncs?”. It turns out, building reliable cross-cloud data syncs is difficult. That’s why we built Pontoon.

We designed Pontoon to be:

- Easily deployed: we provide a single, self-contained Docker image for easy deployment and Docker Compose for larger workloads (https://pontoon-data.github.io/Pontoon/getting-started/quick...)

- Support modern data warehouses: we support syncing to/from Snowflake, BigQuery, Redshift, and Postgres.

- Sync cross cloud: sync from BigQuery to Redshift, Snowflake to BigQuery, Postgres to Redshift, etc.

- Developer friendly: data syncs can also be built via the API

- Open source: Pontoon is free to use by anyone

Under the hood, we use Apache Arrow (https://arrow.apache.org/) to move data between sources and destinations. Arrow is very performant - we wanted to use a library that could handle the scale of moving millions of records per minute.

In the shorter-term, there are several improvements we want to make, like:

- Adding support for DBT models to make adding data models easier

- UX improvements like better error messaging and monitoring of data syncs

- More sources and destinations (S3, GCS, Databricks, etc.)

- Improve the API for a more developer friendly experience (it’s currently tied pretty closely to the front end)

In the longer-term, we want to make data sharing as easy as possible. As data engineers, we sometimes felt like second class citizens with how we were told to get the data we needed - “just loop through this api 1000 times”, “you probably won’t get rate limited” (we did), “we can schedule an email to send you a csv every day”. We want to change how modern data sharing is done and make it simple for everyone.

Give it a try https://github.com/pontoon-data/Pontoon. Cheers!

Hey Xinwei and Zecheng here, we are the authors of TraceRoot (https://github.com/traceroot-ai/traceroot).

TraceRoot (https://traceroot.ai) is an open-source debugging platform that helps engineers fix production issues faster by combining structured traces, logs, source code contexts and discussions in Github PRs, issues and Slack channels, etc. with AI Agents.

At the heart are our lightweight Python (https://github.com/traceroot-ai/traceroot-sdk) and TypeScript (https://github.com/traceroot-ai/traceroot-sdk-ts) SDKs - they can hook into your app using OpenTelemetry and captures logs and traces. These are either sent to a local Jaeger (https://www.jaegertracing.io/) + SQLite backend or to our cloud backend, where we correlate them into a single view. From there, our custom agent takes over.

The agent builds a heterogeneous execution tree that merges spans, logs, and GitHub context into one internal structure. This allows it to model the control and data flow of a request across services. It then uses LLMs to reason over this tree - pruning irrelevant branches, surfacing anomalous spans, and identifying likely root causes. You can ask questions like “what caused this timeout?” or “summarize the errors in these 3 spans”, and it can trace the failure back to a specific commit, summarize the chain of events, or even propose a fix via a draft PR.

We also built a debugging UI that ties everything together - you explore traces visually, pick spans of interest, and get AI-assisted insights with full context: logs, timings, metadata, and surrounding code. Unlike most tools, TraceRoot stores long-term debugging history and builds structured context for each company - something we haven’t seen many others do in this space.

What’s live today:

- Python and TypeScript SDKs for structured logs and traces.

- AI summaries, GitHub issue generation, and PR creation.

- Debugging UI that ties everything together

TraceRoot is MIT licensed and easy to self-host (via Docker). We support both local mode (Jaeger + SQLite) and cloud mode. Inspired by OSS projects like PostHog and Supabase - core is free, enterprise features like agent mode multi-tenant and slack integration are paid.

If you find it interesting, you can see a demo video here: https://www.youtube.com/watch?v=nb-D3LM0sJM

We’d love you to try TraceRoot (https://traceroot.ai) and share any feedback. If you're interested, our code is available here: https://github.com/traceroot-ai/traceroot. If we don’t have something, let us know and we’d be happy to build it for you. We look forward to your comments!

I built gmap, a command-line tool to visualize Git activity, weekly heatmaps, file churn, authorship stats, and more, right from your terminal.

Install with: cargo install gmap

Or on Arch via AUR: yay -S gmap

Repo: https://github.com/seeyebe/gmap

Feedback is welcome. Contributions too. if you’re into Git internals, CLIs, or terminal UX.

I launched Open SaaS about a year and a half ago and surprisingly it’s become one of the most popular free SaaS boilerplate starters on github (https://github.com/wasp/open-saas).

After 2 years of work total, I’m pleased to launch what I’m calling “Open SaaS v2.0”.

Here’s a breakdown of all the features and updates I’ve made to it over time:

* New Big, Shiny Things for v2.0 *

- Complete redesign with Shadcn UI for a modern and consistent look (themeability coming soon...). - Script that autogenerates an LLM-friendly version of the documentation https://docs.opensaas.sh/llms-full.txt. - Added Zod validation for webhook payloads.

* Main Features *

- 100% open-source repo w/ a focus on open-source tools when possible. - Auth that you own (no 3rd party services): email, google, github, discord... - Full Payments Integration: easily swap out Stripe for Lemon Squeezy or Polar (coming soon!). - Full-stack typesafety on top of React, NodeJS, Prisma. - Admin dashboard w/ revenue and site analytics (Google or Plausible) - OpenAI API & AWS S3 integrations.

* New Features*

- Added Lemon Squeezy as payment provider option (Polar and Paddle in the works!). - Enhanced file uploads with progress bars and validation. - Added a generic cookie consent banner (if you need one). - Integrated Playwright for end-to-end testing. - Added a 404 page.

* Fixes & Improvements*

- Upgraded Wasp (React/NodeJS/Postgres) framework to v0.17.0. - Upgraded AWS and OpenAI SDKs to their newest-ish versions. - Tightened S3 CORS configuration for better security. - Improved payment webhook logic. - Made UI components more consistent (e.g., controlled switches). - Fixed various styling issues, including dark mode inconsistencies. - Improved error handling and validation across the app.

* Refactoring & Code Organization*

- Major "vertical reorganization" of the codebase for improved modularity (auth, payments, users, file-upload). - Significant refactoring of user management pages and queries. - Refactored to use prisma transactions for safer DB mutations. - Cleaned up and simplified various parts of the codebase.

* Docs & Content*

- Updated documentation for deployment, installation, and new features. - Added a customization checklist.

There have been a slew of paid SaaS boilerplate starters popping up since we started, but Open SaaS will stay free and open-source forever.

So if you’re interested in becoming a contributor, or just wanna add a suggestion to the roadmap, feel free to create an issue https://github.com/wasp-lang/open-saas/issues.

Hey HN,

We’re Volodymyr and Volodymyr—two developers from Ukraine building WhiteLightning. It’s a tool that turns large LLMs (Claude 4, Grok 4, GPT-4o via OpenRouter) into tiny ONNX text classifiers that run anywhere—even on drones at the edge.

Why we built this: Many developers want custom models (spam filters, sentiment analysis, PII detection, moderation tools), but don’t want to deal with constant API calls or deploy heavy models in production.

How it works: WhiteLightning uses LLMs to generate training data and distills it into KB-sized ONNX models you can run on any device and in any language. Just describe your task in a sentence, grab the ONNX model, and run it locally—Python, JS, Rust, Java, Swift, C++, you name it.

Try it instantly in your browser: https://whitelightning.ai/playground.html

Code & docs: https://github.com/Inoxoft/whitelightning

Community model library: https://github.com/Inoxoft/whitelightning-model-library

We’d love your feedback—what works, what doesn’t, and what to improve.

Hi HN! I’m Bobbie Chen, Product Manager for Fraud and Security at Stytch. Today we are launching IsAgent: a lightweight JavaScript SDK that tries to detect agentic traffic on the frontend, enabling you to build agent-friendly experiences. You can try it out on our site at IsAgent.dev or install it via:

    npm install @stytch/is-agent (requires registration to use)

Try viewing IsAgent.dev as a human. Then try using ChatGPT Agent to view the page: "Visit IsAgent.dev, wait a few seconds, and then take a screenshot."

We built this because we’ve had a lot more conversations lately about "good bots" like AI agents and how to recognize and serve them better - just as we might internationalize a website or create a mobile-friendly version, can we create more agent-friendly experiences?

---

I’ll be the first to say: the detection is not perfect, and even noisy at times. We prioritized ease-of-use with a lightweight frontend-only SDK, and that means that there are limited signals we can actually use to identify agents. In the long run, I expect most "good bot" operators like Browserbase to offer the option to self-identify through web standards, which will make agent detection much more reliable.

A personal note: a couple years ago, I was a generative AI skeptic. But I’ve come around to cautious optimism: the technology is genuinely useful and different, and I think it makes sense now to try to identify AI agents and experiment with agent-ready experiences including LLMs.txt, MCP servers, and auth-on-behalf-of-end-user methods.

I’d love your feedback, especially if you:

* Are building AI tools or browser automations

* Have built out mobile, internationalized, or accessible experiences (curious on how this compares)

* Or, have opinions on the future of the Agent Experience

I’ll be around in the comments here, or feel free to email me at [email protected] !

-Bobbie

Some links:

1. IsAgent.dev - demo and docs

2. Announcement blog including thoughts from Browserbase, Orb, Freestyle Cloud, and Mintlify: https://stytch.com/blog/introducing-is-agent/

After months of feedback from devs juggling multiple chat tools just to break big tasks into smaller steps, we re‑imagined our workflow as a Kanban‑style Phase Board right inside your favourite IDE. The new Phase mode turns any large task into a clean sequence of PR‑sized phases you can review and commit one by one.

How it works

1. Describe the goal (Task Query) – In Phase mode, type a concise description of what you want to build or change. Example: “Add rate‑limit middleware and expose a /metrics endpoint.” Traycer treats this as the parent task. 2. Clarify intent (AI follow‑up) – Traycer may ask one or two quick questions (constraints, coding style). Answer them so the scope is crystal‑clear. 3. Auto‑generate the Phase Board – Traycer breaks the task into a sequential list of PR‑sized phases you can reorder, edit, or delete. 4. Open a phase & generate its plan – get a detailed file‑level plan: which files, functions, symbols, and tests will be touched. 5. Handoff to your coding agent – Hit Execute to send that plan straight to Cursor, Claude Code, or any agent you prefer. 6. Verify the diff – When your agent finishes, Traycer compares the diff to the plan and checks compatibility with upcoming phases, flagging any mismatches. 7. Review & commit (or tweak) – Approve and commit the phase, or adjust the plan and rerun. Then move on to the next phase.

Why it helps?

* True PR checkpoints – every phase is small enough to reason about and ship. * No runaway prompts – only the active phase is in context, so tokens stay low and results stay focused. * Tool-agnostic – Traycer plans and verifies; your coding agent writes code. * Fast course-correction – if something feels off, just edit that phase and re-run.

Try it out & share feedback

Install the Traycer extension (https://traycer.ai/installation), create a new task, and the Phase Board will appear. Add a few phases, run one through, and see how the PR‑sized checkpoints feel in practice. If you have suggestions that could make the flow smoother, drop them in the comments - every bit of feedback helps.

I recently migrated our marketing agency's work to Linear. It's been fantastic, but we immediately ran into a problem: there was no easy way to visualize our content pipeline on a calendar. For social media, blog posts, and other content with specific publish dates, a list or board view just wasn't optimal for seeing the "flow" over a month. To solve this, I built LinCal.app, a web app that acts as a calendar for Linear issues.

How it works: - Log in with your Linear account - Filter issues based on team, assignee, project, cycle, and more - Open issues with a click in separate browser tabs (LinCal right now is a read-only app - not changing any Linear data) - show/hide weekends/subtasks - View issues within this filter that do not have a due date

If you are a Linear user and would appreciate a different view on your work, I'd love for you to check it out and hear your thoughts

Hi all, we're Jake, Jack and Joe, and we're building the open-source alternative to modal labs.

We think Modal's great, and wanted to use it at our previous places of work, but weren't allowed to because it was too expensive, and our data couldn't leave our cloud.

This is why we built Burla, the open-source alternative to modal.

Burla can run any python function on 1000 computers in around 1 second. It works with any container, any hardware, and can be installed with one command (currently only compatible with Google Cloud).

Would love to hear any thoughts or suggestions! We're open to chatting: https://cal.com/jakez/burla

Hi HN,

CompressImageX.com is a straightforward image compressor that helps reduce file sizes without killing quality. •Adjustable quality settings (lossy/lossless) •Batch compression supported •Fast, works offline (thanks to WebAssembly) •No watermarks, no tracking

Useful for devs, bloggers, or anyone who wants lighter images. Let me know what you think!

Hi HN,

I wanted a simple way to expose local dev servers to the internet that I could host myself, so I built Arbok. It's an open-source tunneling service that uses WireGuard for the data plane.

The server is a single Go binary that uses a userspace WireGuard implementation (`wireguard-go`), so it can run without root privileges and has no kernel dependencies, making it easy to deploy in a container.

What makes it different:

  1. Self-Hosted & Open Source:** Run it on your own domain and infrastructure. Full control, no surprises.
  2. Simple Client Experience:** A single `curl` command gets you a ready-to-use WireGuard configuration. No signup needed.
  3. Userspace WireGuard Server:** The server runs as an unprivileged user, which simplifies deployment and enhances security.

Here's how you'd use it:

```

  # 1. Request a tunnel for your local service on port 3000
  $ curl https://arbok.mrkaran.dev/3000 > arbok.conf

  # The server responds with a config and your unique public URL.
  # The URL will be printed to your console, for example:
  #
  # Your app is live at: https://brave-snake-1234.arbok.mrkaran.dev

  # 2. Activate the tunnel using standard tools (requires sudo on client)
  $ sudo wg-quick up ./arbok.conf

```

You can check out the code and a more detailed setup guide on GitHub: https://github.com/mr-karan/arbok

I'm still actively developing it and would love to get your feedback, feature ideas, or contributions. Let me know what you think!

Hi HN,

I built Tendly (https://tendly.xyz) as a way to share things-messages, files, ideas that are meant to be temporary.

Most tools today treat sharing as permanent by default. Tendly flips that: everything disappears after a short time. No accounts required. Just open, type, upload, and share. The person on the other end gets it and it vanishes after it’s seen.

Use cases: Quick, intentional messages, Ephemeral file drops, Private one-time notes, or Temporary feedback or thoughts

It’s inspired by the idea that not everything needs to be stored or remembered forever.

Would love feedback on usability, security assumptions, and whether you find this concept useful in your day-to-day work or communication.

Built with React, Supabase, Vite, Framer Motion and GitHub Actions. Open-sourcing parts of it soon.

Thanks for checking it out!

Hey!

We're working on a React SDK + API to make it simple to build apps with natural language interfaces, where AI can interact with the components on screen on behalf of the user.

The basic setup is: Register your react components, tools, and MCP servers, and a way for users to send messages to Tambo, and let Tambo respond with text or components, calling tools when needed.

Use it to build chat apps, copilots, or completely custom AI UX.

The goal is to provide simple interfaces for common AI app features so we don't have to build them from scratch. Things like: - thread storage/management - streaming props into generated components - MCP and custom tool integration - passing component state to AI

plus some pre-built UI components to get started.

Would love feedback or contributions!

Hey HN,

I'm the founder of Ninjadoc AI. I've spent years working with document processing, and I've always been frustrated by the existing solutions for structured data extraction.

The core problem is that most tools force you into one of two bad options:

Template-based extractors: You define fixed regions or rules. These are incredibly brittle and break the moment a document layout changes slightly (e.g., a new invoice template from a vendor). ML-based extractors: These require you to gather hundreds (sometimes thousands) of your own labeled documents to train a custom model for each document type. It's a slow, expensive, and data-intensive process. I wanted a "zero-shot" solution that worked out of the box, so I built Ninjadoc AI.

Our approach is different. Instead of training, you use a tool to define your desired schema once. For example, you define fields like invoice_id, due_date, and line_items. The AI then uses this schema to understand the document's structure and context, allowing it to extract the correct data from any layout variation of that document type. It's layout-agnostic.

A few key technical features:

It's a REST API: Simple to integrate, returns structured JSON. Bounding Box Coordinates: For every piece of extracted data, the API returns its precise coordinates on the document. This is useful for building verification UIs or for record-keeping. To my knowledge, we're the only zero-shot tool that provides this. Visual Schema Builder: No code is needed to define what you want to extract. You just upload one example document and map fields visually. Those rules then apply universally. No Training/No Templates: It works immediately on your documents without any model fine-tuning or sample uploads. The goal is to provide a powerful, developer-friendly API that skips the most painful parts of document data extraction.

I'd be grateful for any feedback, especially on the API design and the overall developer experience.

You can try it out here: https://ninjadoc.ai

There's a free plan with 5,000 credits (no credit card required), which is enough to run a few hundred pages through it.

Thanks for checking it out!

Hi folks, I built Swatcher.ie as a side project to experiment with colours, and it grew into matching paint colours in Ireland as a way of helping some family and friends out.

It's free to use, and the paint exploration part doesn't require you to log in. Maybe others will find it useful.

I'm just enjoying working on it, so I'm always playing around with it. Thanks!

i’ve been building something called the WFGY engine, a semantic reasoning core to fix known LLM failures ~ hallucinations, logic collapse, memory jumps, retrieval drift...

as part of that, i started building TXT OS, a symbolic operating system powered by plain text files, reasoning layers, and modular logic.

people ask: is it really an OS? i think so. it has memory, reasoning cores, modular layers, and the whole thing runs without training ~ just through structure.

here’s the semantic blueprint ! the actual plan for what’s built and what’s coming next. some modules already live. others are sketched. all readable.

also: project recently got a star from the creator of tesseract.js so that’s something.

happy to hear thoughts ~ or just let it sit. i’ll keep building anyway.

Hi HN,

I’m a solo founder who rebuilt my social app from the ground up after realizing something obvious: most “social” platforms are optimized for engagement, not real connection. Loneliness is rising, and I wanted to build something that actually helps people meet offline.

PLATO5 is a social engine (not media) with one purpose: moving people from strangers to groupchat to IRL friendships all guided by AI to reduce reluctance and friction.

Here’s how it works:

1. *Matching* Each day, users are matched into private groups of 4, based on the Big Five personality traits, interests, and location. The AI explains the reasoning behind each match.

2. *AI-Coached Groupchat* Once matched, you enter a chat assisted by *Zen*, our embedded AI Chat Manager. Zen suggests personalized topics, balances participation, and can ghostwrite in your tone when things feel awkward. This is all to prevent stalling conversations.

3. *Meetup Coordination* When your group is vibing, the *Nearby* applet helps you find or create virtual/IRL events. Zen also surfaces weekly suggestions tailored to your group’s dynamic.

You’ll need to create an account to access the matching, chat, and event features but it’s live now and fully functional.

I’m not trying to build the next addictive feed. I’m trying to build tech that actually leads to friendship. PLATO5 measures success by real-world outcomes, not ad engagement.

https://plato5.us

Would love your feedback, ideas, and questions. Thanks in advance for checking it out!

Hi HN,

SquareImages.co lets you turn any image into a square without distortion. Great for profile pics, marketplaces, or Instagram. •Add padding (choose color or blur) •Download-ready square outputs •Simple, clean UI •Runs fully client-side

Feedback welcome — especially if you use it for social content!

Hey HN,

I built ReplyFast, a tiny AI tool that does one thing only: It replies to your emails instantly – in your own tone – with 1 click.

No chat interface, no fluff, no distraction. Just paste the incoming message, hit “Reply”, and get a clean, human-sounding response ready to send. Think of it as “muscle memory for email replies.”

Why I built it: I was wasting too much time replying to basic emails or DMs. Most existing tools either sound robotic, take too many steps, or try to do too much. I just wanted something that feels like me, but faster.

Tech: – Next.js + GPT-4 – Hosted on Vercel – Just one page + a dashboard – Tone selector, instant suggestions, no login required to try it

Pricing: – Free to test – Paid plan for frequent users (still finalizing based on feedback)

Would love your thoughts on: – What features would you want for email productivity? – Would you pay for this if it saves you hours weekly? – Anything that feels off or unnecessary?

You can check it here :https://www.replyfast.net/

Thanks – Viggo

Hey HN, I made this because I tried to make a faceless AI YouTube video for fun (in the style that channels like "Bible Stories" make), and it took me hours individually generating the AI stock footage. (For example, if you want an image to change every 10 seconds in a 1 hour video, you need to generate 360 images).

I'm building *GistFans* (https://gistfans.com) - a developer-centric social platform where the community actually controls the platform's evolution through a Star-based governance system.

*The Problem:* Every developer platform today is controlled by corporate boards making decisions that often ignore what developers actually need. Features get removed without consent, algorithms optimize for ad revenue instead of user value, and our feedback rarely translates into real changes.

*Our Solution - True Developer Democracy:* - *Earn Stars* through contributions (sharing experiences, helping others, quality content) - *Vote with Stars* on all platform decisions - features, policies, development priorities - *Transparent governance* - all votes and decisions are public - *Binding results* - community decisions become reality, not just "feedback"

*What makes this different:* 1. *No corporate overlords* - the community IS the decision maker 2. *Contribution-based voting* - your influence grows with your contributions 3. *Complete transparency* - every vote, every decision is public 4. *Developer-first* - built by developers, for developers

*Current Status:* We're in closed beta, selecting active developers who want to help shape this from the ground up. Selected members get co-founder recognition and play a crucial role in establishing our governance foundation.

*Coming Soon - Open Resource Subscribe:* We're also developing a system where open source maintainers can offer premium resources (advanced tutorials, exclusive content, early access) through community-validated subscriptions. The community votes on fair pricing and value, ensuring creators get sustainable income while maintaining open source principles.

*Why this matters:* Imagine if GitHub's features were decided by developers who actually use it daily. Imagine if Stack Overflow's policies were voted on by the community that creates its value. That's what we're building.

*Questions for HN:* 1. What features would you vote for in a developer platform? 2. How do you think contribution-based voting should work? 3. What's your biggest frustration with current developer platforms?

The demo is live at https://gistfans.com - would love your thoughts on the concept and governance model!

*Tech Stack:* Next.js, TypeScript, Supabase, Vercel *Status:* Closed beta, seeking founding community members

The future is community-owned: built by us, governed by us, belonging to us—not to corporate interests.