2025年10月27日 の Show HN

I built a Vite plugin that lets you write Go code directly in .js files using a "use golang" directive. It compiles to WebAssembly automatically.

I'm working on a tool that will probably involve querying JSON documents and I'm asking myself how to expose that functionality to my users.

I like the power of `jq` and the fact that LLMs are proficient at it, but I find it right out impossible to come up with the right `jq` incantations myself. Has anyone here been in a similar situation? Which tool / language did you end up exposing to your users?

Hey HN! We’re Jorge and Will from Lotas (https://www.lotas.ai/), and we’ve built Erdos, a secure AI-powered data science IDE that’s fully open source (https://www.lotas.ai/erdos).

A few months ago, we shared Rao, an AI coding assistant for RStudio (https://news.ycombinator.com/item?id=44638510). We built Rao to bring the Cursor-like experience to RStudio users. Now we want to take the next step and deliver a tool for the entire data science community that handles Python, R, SQL, and Julia workflows.

Erdos is a fork of VS Code designed for data science. It includes:

- An AI that can search, read, and write across all file types for Python, R, SQL, and Julia. Also, for Jupyter notebooks, we’ve optimized a jupytext system to allow the AI to make faster edits.

- Built-in Python, R, and Julia consoles accessible to both the user and AI

- Plot pane that tracks and organizes plots by file and time

- Database pane for connecting to and manipulating SQL or FTP data sources

- Environment pane for viewing variables, packages, and environments

- Help pane for Python, R, and Julia documentation

- Remote development via SSH or containers

- AI assistant available through a single-click sign-in to our zero data retention backend, bring your own key, or a local model

- Open source AGPLv3 license

We built Erdos because data scientists are often second-class citizens in modern IDEs. Tools like VS Code, Cursor, and Claude Code are made for software developers, not for people working across Jupyter notebooks, scripts, and SQL. We wanted an IDE that feels native to data scientists, while offering the same AI productivity boosts.

You can try Erdos at https://www.lotas.ai/erdos, check out our source code on our GitHub (https://github.com/lotas-ai/erdos), and let us know what features would make it more useful for your work. We’d love your feedback below!

Meals You Love is a meal planning app that creates weekly meal plans tailored to your tastes and dietary preferences. It integrates with Kroger and Instacart's APIs so you can add your meal plan groceries directly to your cart. You can also import your own recipes to include alongside AI suggestions.

I originally built this to help my wife with meal planning and grocery shopping. We were always struggling to decide what to make and inevitably forgot ingredients. Most meal planners felt too rigid or generic, and few handled the grocery side well (or at all). We've also used meal kits like Home Chef in the past but they end up being quite expensive and produce a comical amount of packaging waste, plus you still wind up needing to purchase groceries anyway. In all honesty, I also wanted an excuse to try building something "real" using AI and to see if it could be used in an actually useful manner.

Would love feedback from anyone interested in food, meal planning, or product design!

Tech stack:

- Cloud Run

- Firestore

- Vertex AI / Gemini

https://mealsyoulove.com

GAC is a tool I built to help users spend less time summing up what was done and more time building. It uses LLMs to generate contextual git commit messages from your code changes. And it can be a drop-in replacement for `git commit -m "..."`.

Example:

``` feat(auth): add OAuth2 integration with GitHub and Google

- Implement OAuth2 authentication flow - Add provider configuration for GitHub and Google - Create callback handler for token exchange - Update login UI with social auth buttons

```

Don't like it? Reroll with 'r', or type `r "focus on xyz"` and it rerolls the commit with your feedback!

You can try it out with uvx (no install):

``` uvx gac init # config wizard uvx gac ```

_Note: `gac init` creates a .gac.env file in your home directory with your chosen provider, model, and API key._

*Tech details:*

*14 providers* - Supports local (Ollama & LM Studio) and cloud (OpenAI, Anthropic, Gemini, OpenRouter, Groq, Cerebras, Chutes, Fireworks, StreamLake, Synthetic, Together AI, & Z.ai (including their extremely cheap coding plans!)).

*Three verbosity modes* - Standard with bullets (default), one-liners (`-o`), or verbose (`-v`) with detailed Motivation/Architecture/Impact sections.

*Secret detection* - Scans for API keys, tokens, and credentials before committing. Has caught my API keys on a new project when I hadn't yet gitignored .env.

*Flags* - Automate common workflows:

- `gac -h "bug fix"` - pass hints to guide intent - `gac -yo` - stage all files and auto-accept the commit message in one-liner mode - `gac -ayp` - stage all files, auto-accept the commit message, and push

Would love to hear your feedback! Give it a try and let me know what you think! <3

GitHub: https://github.com/cellwebb/gac

Hi HN! I’m Johan. I built Dlog, a journaling app with an AI coach that tracks how your personality, daily experiences, and well-being connect over time. It’s based on my PhD research in entrepreneurial well-being.

How Dlog works • Journal and set goals/projects; Dlog scores entries on-device (sentiment + narrative signals) and updates your personal model. • A built-in structural equation model (SEM) estimates which factors actually move your well-being week to week. • The Coach turns those findings into specific guidance (e.g., “protect 90 minutes after client calls; that’s when energy dips for you”). • No account; your journals live locally (in your calendar). You decide what, if anything, leaves the device.

The problem • Generic AI coaches give advice without understanding your personality or context. • Traditional journaling is reflective but doesn’t surface causal patterns. • Well-being apps rarely account for individual differences or test what works for you over time.

What my research found (plain English) In my PhD I modeled how Personality, Character, Resources, and Well-Being interact over time. The key is latent relationships: for example, Autonomy can buffer the impact of low Extraversion on social drain, while time/energy constraints mediate whether “good advice” is actionable. These effects are person-specific and evolve—so you need a model that learns you, not averages.

The solution Dlog pairs on-device journaling analytics with an SEM that updates weekly. You get a running estimate of “what moves the needle for me,” and the Coach translates that into concrete suggestions aligned with your goals and constraints.

Early stories (anonymized from pilot users) • A founder saw energy dips clustered after external calls; moving deep work to mornings reduced “bad days” and improved weekly mood stability. • A solo designer’s autonomy scores predicted well-being more than raw hours worked; small boundary changes (client comms windows) helped more than time-tracking tweaks.

Tech & security • Platform: macOS (Swift/SwiftUI). Data: local storage + EventKit calendar for entries/timestamps. • Analytics: on-device sentiment + narrative features; SEM computed locally; weekly updates compare to your baseline. • AI Coach: uses an enterprise LLM API for reasoning on derived features/summaries. By default, raw journal text does not leave the device; you can opt-in per prompt if you want the Coach to read a specific passage. • Why 61 baseline variables? The SEM needs multiple indicators per construct (Personality, Character, Resources, Well-Being) to estimate stable latent factors without overfitting; weekly check-ins refresh those signals.

What I’ve learned building this • Users value clarity with depth: concise recommendations paired with focused dashboards, often 5–10 charts, to explain the “why” and trade-offs. • Cold start matters: a solid baseline makes the first week of insights credibly useful. • Privacy UX needs to be explicit: users want granular control over what the Coach can read, per request.

I’m looking for feedback on: • Onboarding (baseline survey and first-week experience) • Coach guidance clarity and usefulness • Analytics accuracy vs. your lived experience • Edge cases, bugs, and performance

Download: https://dlog.pro

If you hit token limits while testing, email me at [email protected]

Background PhD (Hunter Center for Entrepreneurship, Strathclyde), MBA (Babson), BComm (UCD). I study solo self-employment and well-being, and built Dlog to bring that research into a tool practitioners can use.

Note: The Coach activates after your first scored entry. If you haven’t written one yet, you’ll see a hold state—add a quick journal entry and it unlocks.

Appearance: On a few Macs the initial theme can render darker than intended. If you see this, switch to Light Mode as a temporary workaround; a fix is incoming.

I thought it'd be fun to make a point-and-click adventure game based around music. I thought it'd be a unique take on the gnre. I made this game for a 7-day gamejam and drew all the artwork and created all the music myself. It can be played through to completion in about 5 minutes.

I built nblm, a Rust-based toolset to automate Google’s NotebookLM Enterprise API reliably. It aims to replace brittle curl snippets with a stable interface you can use in cron/CI or agentic systems.

* Python SDK (type-safe): IDE auto-complete, fewer JSON key typos, fits complex workflows.

* Standalone CLI: single fast binary for scripts and pipelines.

* Handles auth, batching, retries; you focus on logic. Rust core is fast and memory-safe.

* Enterprise API only (consumer NotebookLM isn’t supported).

Repo: https://github.com/K-dash/nblm-rs

Feedback is welcome—I'm especially interested in thoughts on the Python SDK’s design for building automated/agentic workflows. Thanks!

I built this after spending days every year manually searching through Jira tickets to remember what I'd accomplished for performance reviews.

whatdidido is a CLI tool that:

- Pulls tickets from Jira or Linear for a date range

- Uses an LLM to create short summaries of each ticket

- Generates an overall summary to help you build your self-evaluation

The tool doesn't write your review for you—crafting thoughtful, contextual feedback still requires human judgment. It just eliminates the busywork of finding and organizing what you worked on.

Key details:

- MIT licensed, open source

- No data storage—everything stays local

- Requires OpenAI or OpenRouter API key

- Works with Jira and Linear (more integrations welcome/coming soon)

GitHub: https://github.com/oliviersm199/whatdidido

I'm releasing it now because I think others might find it useful during review season.

Would love feedback on the approach and what other integrations would be helpful. Happy to answer questions about how it works.

I just shipped something I’ve needed for years - a more efficient email client.

I finally built Omnia OS because my inbox turned into a landfill of AI-generated noise. If you're going to email me going forward, I suggest including a more compelling subject and opening line, otherwise all emails from unknown people will not make it to my inbox. AI draft-suggestion tools never solved the real problem: finding the messages, files, or company I actually need to follow up with. After securing AI systems for a living, I know how easy it is to weaponize prompt injection, so bolting AI onto email without redesigning the core experience felt reckless. First, we need to separate trusted from untrusted senders, then decide whatever touches automation.

Omnia OS is the email client I now rely on: New senders/orgs are isolated until you approve them, so domain spoofing means you will not make it to the inbox anymore, because it will be isolated as a new organization that needs approval.

Catch-up view shows everything that happened since you last checked:

- meetings, threads, urgent items.

- Every company you work with has its own space for contact lists, file management, and basic company intel, so you stop searching through old chains.

- Mass unsubscribe and delete emails

Coming back to work on Monday or a long weekend used to take half a day reviewing emails. Now you see what matters, act, and move on.

It's free to use as a desktop app for your email client on MacOS.

Install from https://omniaos.co

*Since this is my side project, the initial build only supports MacOS and Gmail. Happy to collaborate on new capabilities.

Hi HN,

As a huge manga fan and a translator by training, I've always been in awe of the incredible amount of work that fan translators put in. The process isn't just about translation; it involves manually cleaning the original text from the bubbles, redrawing the background art (inpainting), and then carefully placing the translated text back in (typesetting). It's a true labor of love, but it's incredibly time-consuming.

I wondered if modern AI could help automate the most tedious parts of this workflow. So, I built AIFandom.

It's a web tool where you upload your manga pages, and it extracts the text from the speech bubbles and translates the text, but with a key difference: The model doesn't just read the text, it also looks at the visual context of the panel to better capture the original tone and nuance.

Then, It automatically removes the original text, uses an inpainting model to intelligently redraw the artwork that was behind the text, and then typesets the translated text back into the bubbles.

The end result is a fully translated and readable manga page that you can download.

I use gemini for the translation process and various models for OCR, inpainting, masking, rendering.

It's not a free tool. This whole process is computationally expensive and requires a good amount of GPU time. To cover these costs, I've priced it at $7/month for 1000 pages.

However, I really want you to see the quality for yourself, so there is a 50-page free trial for everyone to test it out, no credit card required upfront.

I would be incredibly grateful for your feedback.

- How is the translation quality and tone? - Does the automatic typesetting look natural to you? - Is the pricing fair for the value it provides? - What features should I prioritize adding next?

Thanks for checking it out! I'll be here all day to answer any questions.

Hey HN!

I built vetr.is, a cloud hosting in Iceland focused on privacy and renewable energy.

*What it offers:* - Iceland location with 100% renewable energy - AMD Ryzen CPUs + NVMe storage - Hourly billing, no contracts - Price-locked subscriptions - Tor-friendly interface

*Pricing:* Starting at €5/month for 1 CPU, 0.5GB RAM, 10GB storage. Pay only for what you use.

https://vetr.is

Happy to answer questions!

Hello HN!

I just published my first npm library as a small way to give back to the open source community.

I built `spoilerjs`, a lightweight web component that lets you hide text with an animated spoiler effect. Think Reddit spoilers, but with more flair! It works with plain HTML, React, Vue, or Svelte, and you can customize attributes like particle density, velocity, and scale. The effect is totally inspired by the Telegram app!

Demo: https://spoilerjs.sh4jid.me NPM: https://www.npmjs.com/package/spoilerjs GitHub: https://github.com/shajidhasan/spoilerjs

I'm sure there are probably some bugs and rough edges, but I'd love to hear your feedback!

Thanks!

Tired of copy-pasting the same question across ChatGPT, Claude, Gemini, and Grok to find the best answer?

I built ChatHawk to solve this exact problem: Ask once and get responses from all top AI models simultaneously, plus an AI-generated combined answer that pulls the best insights from each.

Perfect for when you need accurate answers (verified across models), strategic decisions, or multiple AI perspectives. Stop the tedious switching between platforms – get comprehensive AI insights in one place.

What questions would you want to run through all models at once?

What relai-sdk is an open-source toolkit for making AI agents reliable via a complete learning loop: simulate → evaluate → optimize.

Why Agent runs are stochastic; tool-calls fail; hard to reproduce, measure, and fix at scale. It’s also hard to align behavior with goals across output quality/format, cost, and latency. We need a loop that integrates user feedback and LLM evaluators directly into the agent code (prompts, configs, models, graphs) without overfitting.

How - Simulation: LLM personas, mocked MCP servers/tools, synthetic data; can condition on real traces - Evaluation: code-based + LLM-based evaluators; turn human reviews into optimization-ready benchmarks - Optimization with Maestro: tune prompts, configs and even agent graph for improved quality, cost and latency

Try it pip install relai

GitHub: https://github.com/relai-ai/relai-sdk

Docs: https://docs.relai.ai/ (2-min overview: https://youtu.be/qKsJUD_KP40)

Looking for feedback on - Where graph-level suggestions help (beyond prompt tuning) - Evaluator signals you rely on for reliability (and what we’re missing) - Simulation setups/environments you’d want out of the box

Notes Founder here. Happy to share internals, tradeoffs, and limitations.

Works with LangGraph / OpenAI Agents / Google ADK / etc. SDK Apache-2.0 license.

HanView fetches the stunning daily Bing wallpaper (every 3 hours), uses AI to seamlessly overlay a random frequently used Chinese word, and sets the enriched image as your Windows wallpaper. It’s a perfect way to "encounter" a Chinese word, effortlessly—blending the beauty of the world with the richness of language, right on your desktop.

Hello. This is an updated version of my TrueType rasterizer - now it has few solid color modes, gradient color modes and underline functionality. Also, it's a C project now (it started as a C++). I wanted to implement precomputed glyphs (and maybe strings) in this version but this will wait for some time, as this is a side project for me and this functionality is not that trivial as it may sound at first.

I finally got around to making a tool I've wanted for a long time: you can basically think of it as being "like Gmail for coding agents."

If you've ever tried to use a bunch of instances of Claude Code or Codex at once across the same project, you've probably noticed how annoying it can be when they freak out about the other agent changing the files they're working on.

Then they start doing annoying things, like restoring files from git, in the process wiping out another agent's work without a backup.

Or if you've tried to have agents coordinate on two separate repos, like a Python backend and a Nextjs frontend for the same project, you may have found yourself acting as the go-between and liaison between two or three different agents, passing messages between them or having them communicate by means of markdown files or some other workaround.

I always knew there had to be a better way. But it's hard to get the big providers to offer something like that in a way that's universal, because Anthropic doesn't want to integrate with OpenAI's competitive coding tool, and neither wants to deal with Cursor or Gemini-CLI.

So a few days ago, I started working on it, and it's now ready to share with the world. Introducing the 100% open-source MCP Agent Mail tool. This can be set up very quickly and easily on your machine and automatically detects all the most common coding agents and configures everything for you.

I also include a ready-made blurb (see the README file in the repo) that you can add to your existing AGENTS dot md or CLAUDE dot md file to help the agents better leverage the system straight out of the gate.

It's almost comical how quickly the agents take to this system like a fish to water. They seem to relish in it, sending very detailed messages to each other just like humans do, and start coordinating in a natural, powerful way. They even give each other good ideas and pushback on bad ideas.

They can also reserve access to certain files to avoid the "too many cooks" problems associated with having too many agents all working on the same project at the same time, all without dealing with git worktrees and "merge hell."

This also introduces a natural and powerful way to do something I've also long wanted, which is to automatically have multiple different frontier models working together in a collaborative, complementary way without me needing to be in the middle coordinating everything like a parent setting up playdates for their kids.

And for the human in the loop, I made a really slick web frontend that you can view and see all the messages your agents are sending each other in a nice, Gmail-like interface, so you can monitor the process. You can even send a special message to some or all your agents as the "Human Overseer" to give them a directive (of course, you can also just type that in manually into each coding agent, too.)

I made this for myself and know that I'm going to be getting a ton of usage out of it going forward. It really lets you unleash a massive number of agents using a bunch of different tools/models, and they just naturally coordinate and work with each other without stepping on each other's toes. It lets you as the human overseer relax a bit more as you no longer have to be the one responsible for coordinating things, and also because the agents watch each other and push back when they see mistakes and errors happening. Obviously, the greater the variety of models and agent tools you use, the more valuable that emergent peer review process will be.

Anyway, give it a try and let me know what you think. I'm sure there are a bunch of bugs that I'll have to iron out over the next couple days, but I've already been productively using it today to work on another project and it is pretty amazingly functional already!

Hi HN! Really grateful for the feedback and users over the past couple of months, the Show HN community has been so helpful! We've recently improved some core pain points affecting our Ubik users.

What's New?

1. Improved PDF ingestion: wait times have been reduced, varying times based on size & # of PDFs uploaded (DOCX soon, wait for files to turn green in context bar). 2. Simplified layout: Panel option added (top right of page). 3. Added models: 200+ frontier/experimental models. 4. Compare Canvas: See text documents (Canvas) side by side, apply changes where you see fit. 5. Improved system prompt/tool calling: Agents are more aware of all tool purposes. 6. Abstract page: not all papers are open-access - new abstract page has core info and routes to DOI.

What is Ubik? Ubik is an AI Research Environment (AiRE). With context-aware agents, academic database access (ArXiv/Semantic Scholar), and consistent human approval, Ubik improves agentic capabilities, minimizes hallucination, and makes LLM-assisted writing usable in high-level research and citation-based work. How does Ubik do this?

Agent Orchestration We build our agents optimized around their environments, not a specific model, making it easy to run them in the cloud, on devices, and eventually with local models.

Dynamic Context Engine This helps the AI and the human understand the larger project at hand, as well as any research criterion (citation styling, topic area focus, finding new sources, context of a project)

1. NOT just embeddings or semantic search! 2. Custom document parsing and enhanced OCR for in-text citations and transparent AI output 3. Agentic analysis to extract, understand, and markup documents beyond single questions 4. Like Cursor, Ubik knows your workspace. For improved accuracy, you can reference all files and agent-made items (notes/canvas) while prompting using the @ symbol.

Why did we build Ubik? Because generative tools help experts and hurt beginners, quick solutions to complex problems without friction/interactivity between the initial prompt and the desired output don’t build cognitive skills in beginners that experts have mastered without AI (vibe code, vibe physics, vibe xyz = AI slop). Unlike beginners, experts amplify their human intelligence because they can correct AI output and understand when the model/agent is unhelpful or hallucinating; this is intellectual agility, a critical skill for effective AI use.

https://stackoverflow.blog/2025/08/07/a-new-worst-coder-has-... https://simonwillison.net/2025/Oct/7/vibe-engineering/ https://bigthink.com/starts-with-a-bang/vibe-physics-ai-slop...

The Cognitive Cost: MIT is conducting an ongoing neurological study on ChatGPT users' brain activity while using the AI chatbot to complete tasks. MIT's early findings are worrying. LLM-assisted writers could not complete writing tasks effectively or efficiently. What does this mean? Critical thinking skills and intellectual agility crumble when we treat AI as an oracle.

https://www.media.mit.edu/projects/your-brain-on-chatgpt/ove... https://bigthink.com/business/ai-will-never-be-a-shortcut-to...

Ubik v1 Today: https://app.ubik.studio is live (v1). Our current 260 users (researchers, scientists, and students) who use Ubik for their citation-based work. Before we release the full Ubik App, the platform will be free! Sign up for our PDF analysis tools, and please reach out with any feedback.

Ubik App v2 (electron app) Coming Soon: Reduces all wait times on PDF ingestion, unifies our agents, and is built ready for local, on-machine models. We are working on our custom eval suite for knowledge work/evidence attribution (reach out to learn more).

If you are interested in a demo of our full app, would like to enter a beta/testing group for the app, or want to understand more about Ubik, please email me: [email protected]

hey hn, wrote a python library for myself to visualize tensors. Makes learning and debugging deep learning code so much easier. Works seamlessly with colab/jupyter notebooks, and other python contexts. It's built on top of the graphics backend, chalk (https://chalk-diagrams.github.io/).

why?

Understanding deep learning code is hard—especially when it's foreign, because it's hard to imagine tensor manipulations, e.g. `F.conv2d(x.unsqueeze(1), w.transpose(-1, -2)).squeeze().view(B, L, -1)` in your head. Printing shapes and tensor values only get me so far. tensordiagram lets me quickly diagram tensors.

Other python libraries for creating tensor diagrams are either too physics and math focused, not notebook-friendly, limited to visualizing single tensors, and/or serve a wider purpose (so have a steep learning curve).

Just got the first open testing release approved on google play store for a minimal android launcher i'm developing.

I recently switched to a phone with an e-ink display and was missing features in current minimal launchers, so i decided to make my own.

Would love to hear your opinion, improvements that could be made or features to change/add.

Thanks!

=== Links ===

    - https://play.google.com/store/apps/details?id=com.kolktech.mnml
    - https://www.youtube.com/watch?v=6gcF9lSDBPY (video demo)

=== Current Features ===

    - Multiple rows of apps
    - Material Font icons can be set as app names
    - When reducing or increasing apps you can re-order and select which apps to keep (this is missing from a lot of minimal launchers imo)
    - App shortcuts (long press on an app to show that app's own shortcut menu)
    - Backup your launcher settings with Export/Import
    - App drawer list (swipe up)
    - You can hide apps from the app list
    - You can uninstall apps from the app list
    - App rows can have their size individually set.

=== Planned features ===

    - Background images or static colors
    - Show weather information
    - Screen time usage information
    - Possibly some limited widgets
        - google search bar on the bottom?      
        - Notes on the main screen  
    - App folders (so you can assign multiple apps to one slot)
    - App slot assignment other than apps
        - URL's
        - Files
        - Intents
        - Contacts
        - etc.
    - More gestures that you can assign actions to
        - 3 or 4 finger swipe
        - triple tap
        - pinch zoom
        - etc.
    - Find contacts and files in the app list
    - Localization

I made pinpam, a PAM module and utility to enable authentication on Linux with a brute-force resistant, TPM2-backed pin, intended to supplement (not replace) traditional password based Unix authentication. I created this because I wanted the convenience of a phone-like PIN unlock for my Linux device, with improved security over existing solutions like simply setting your password to a number. Generally a pin is less secure than a strong password, but they can be more convenient and easier for users to embrace. Please carefully consider your threat model when implementing any authentication service.

TLDR: I built a "quick and dirty " private social network for my friends, posted on Reddit and HN, got some interest so now have built it properly along with my brother.

site link: https://intimost.com/login/

demo creds:

[email protected] Demo123!

Full version:

I needed a social network where I can just send updates and nothing else. So I built it, my friends liked and now I have built it "for the world".

Everything is private by default.

- Text-only updates - No likes. Only views to acknowledge a post - [in development] Comments are private between the poster and commenter - Friends not followers - Profiles are not searchable - You need the user's `Friend Code` to find a profile - Feed shows updates from your friends and nothing else

More context:

Original Reddit post (a few months ago): https://old.reddit.com/r/digitalminimalism/comments/1kuuv8h/... Launch post (today): https://old.reddit.com/r/digitalminimalism/comments/1oh935z/...

I am looking for feedback and thoughts!

(You can use a dummy email to signup and delete the account a few clicks afterwards)

A lot of users are asking for photos, we are trying to figure out how to do that in a "clean" way

Thank you - J

Hey everyone,

I made a small tool called osync, a setup that uses Git and rsync to sync and back up directories between devices. It started as a personal experiment to sync my Obsidian notes between my PC and phone without relying on cloud storage or overcomplicated tools. I thought it would be simple, just SSH and rsync, but it turned into a great learning experience.

Now the script can, once SSH, systemd, and the works are set up, automatically sync between two computers reliably while also backing up to a Git repository.

GitHub: https://github.com/Kena-Njonge/osync

I also wrote a blog post https://open.substack.com/pub/kenakiruri/p/how-i-backup-and-... that goes over the motivation and acts as a tutorial if you want to use the tool to sync your Obsidian vaults. It also covers some of the differences between this setup and other alternatives.

Would love to hear your thoughts, especially on how I could improve it from a software engineering perspective.

Thanks!

Hey HN!

I built Chime - a macOS app that shows full-screen meeting alerts for people who lose track of time while in deep work mode (like me).

The problem: Calendar notifications are too subtle when you're in deep focus. I kept missing meetings/reminders and felt terrible about it.

The solution: Full-screen alerts 5 minutes before meetings that you literally can't ignore (time is customisable). Plus auto-detection of Zoom/Teams/Meet/etc links for one-click joining.

Tech stack: Native Swift/SwiftUI, EventKit for calendar integration, local-first (your data stays on your Mac).

Landing page: https://usechime.app

I'm looking for ~50 beta testers to try it via TestFlight before the official launch. Especially interested in: - Techies who have this same problem - Feedback on the alert timing and design - Edge cases with different calendar setups - Privacy-conscious users (happy to discuss implementation)

If you're interested, there's a waitlist link on the site. I'll send TestFlight invites to the first respondents.

Would also love general feedback on the concept!

Hi HN,

Over the past several months we’ve been building Shivon AI, a platform aimed at candidates getting ready for interviews. The core idea: let you simulate real interviews with an AI (any domain, any role), generate a detailed performance report, and then share that report as part of your job-application portfolio.

Key features: A chat-based AI interviewer that asks theory, practical usage and case-study style questions. After each simulation you receive a breakdown of your performance across metrics (e.g., communication, problem solving, confidence) with actionable suggestions. You can track improvements over time and share your interview-report as tangible evidence of your prep. We just launched the beta at https://candidate.shivonai.com (no paywall; demo mode available).

Why we built this: We’ve seen how difficult it can be for candidates to highlight their real skills beyond a résumé or LinkedIn profile. Interview preparation often happens in isolation, with no way to measure improvement or share results. Our goal is to make this process measurable, transparent, and empowering for every job seeker.

We’re looking for feedback from the HN community especially around: How realistic/interview-like the AI questions feel (domain-agnostic). Whether the performance report adds value and how it could be improved. Thoughts on sharing such a report as part of a portfolio — does it meaningfully affect job odds, or feel gimmicky?

Happy to answer questions on the architecture, data pipeline, UI/UX, even business model if you’re interested.

Thanks for checking it out — looking forward to the discussion.

Vraj Patel, Shivon AI