DEV Community: niixolabs

TenjiScan: we shipped an on-device Japanese braille reader for iPhone

niixolabs — Thu, 28 May 2026 23:02:53 +0000

Japanese braille shows up in places most people walk past without thinking — the textured rail at a train station, the edge of a pill box, the panel beside an elevator button. It's present, it carries information, and almost nobody can read it.

TenjiScan started from that observation. Point your iPhone camera at Japanese braille and get the text back on the spot. That's the whole pitch.

Why on-device processing mattered

The obvious implementation would be: send the photo to a server, run recognition there, return text. Faster to ship, potentially higher accuracy.

We didn't do that, for two reasons. First, the places where you'd actually want to read braille — subway stations, hospital hallways — are often places with weak or no connectivity. Second, you're sometimes photographing medication labels or personal items. Sending those images to a server creates a privacy concern that isn't worth carrying.

Since v4.0.0, everything runs locally. Vision framework plus a custom two-signal pipeline handles cell boundary detection first, then dot presence per cell. No image leaves the device.

What it supports

Japanese braille (JIS) and English braille (UEB Grade 1) are both covered. That handles the majority of real-world signage.

The honest limitation: Grade 2 contracted braille isn't supported yet. And recognition quality depends on lighting and camera angle — braille is a physical texture, so how light falls across it directly affects what the camera sees. Flat, even lighting and a straight-on angle give the best results.

Shipping a niche tool

One thing about building accessibility tools: the use case is clear. You know exactly what you're solving and for whom. That focus made some decisions easier — we didn't try to expand scope to other braille systems or add cloud features. It does one thing, on-device, with no account required.

Free to download. Optional one-time purchase removes ads.

App Store: https://apps.apple.com/jp/app/id6759526188

We built an app for Japan's neighborhood associations — and learned that invisible work is the hardest problem

niixolabs — Wed, 27 May 2026 23:04:18 +0000

The problem

Japanese neighborhood associations — jichikai or chonaikai — run almost entirely on volunteer labor. Someone collects dues house by house. Someone else delivers the bulletin board. Another person organizes the safety drill, coordinates the annual meeting, and writes the handover notes for whoever takes over next year.

None of that work gets logged anywhere. It's invisible. So when officer recruitment comes around, no one wants to step up — not because the work is impossible, but because no one knows how much of it there actually is, and the person who did it last year is already tired. The same people cycle through exhaustion. The same conversation happens every year.

What Musubiba does

Musubiba makes every officer's contribution measurable. Bulletin circulation, dues collection, safety check-ins, meeting votes, annual scheduling, and handover documentation — all tracked, all visible, all handed off cleanly when roles rotate.

The goal isn't automation. It's making the workload legible so that it can be shared more fairly, and so that new officers aren't starting from zero every cycle. The handover notes feature matters more than you'd expect: a successor who inherits a full activity record behaves differently than one starting from a blank slate.

Technical choices

Flutter for iOS and Android — neighborhood associations span every device type, and a single Dart codebase was the only realistic path. Backend is Firebase; Firestore's real-time listeners handle safety check-ins and live vote tallies. Billing runs on both Stripe and in-app purchases to cover the web-based accounting input path, because some committee leads are more comfortable with a browser than a smartphone. New members join by scanning a QR code — no invite emails to manage.

Honest caveat

This is optimized specifically for Japan's jichikai system. The workflows — how bulletins circulate, how dues are collected, how officer roles are defined — are Japan-specific enough that it won't map well to HOAs in other countries. We chose depth over generality.

Pricing: free up to 15 members; ¥1,500/month for unlimited.

App Store: https://apps.apple.com/jp/app/musubiba/id6759871374

Google Play: https://play.google.com/store/apps/details?id=com.htor.musubiba

We built a budgeting app that doesn't want your bank password

niixolabs — Tue, 26 May 2026 23:03:35 +0000

The starting point

Most budgeting apps open with the same ask: connect your bank. It's a reasonable UX move — automatic imports reduce friction significantly. But it also means your banking credentials flow through a third-party aggregator. Some people are fine with that. A meaningful slice aren't.

We built moneasy for the second group.

Two input methods, nothing else

The entire logging surface is: talk to Siri, or photograph a receipt.

Describe what you spent and Siri routes it into the app. Receipt OCR via Vision reads amounts from the photo automatically. Voice processing runs through Apple Speech and Gemini 2.5 Flash, covering 25 languages. Data lives on device and in iCloud via SwiftData + CloudKit — nothing touches external servers.

The tradeoff we accepted

No bank-API integration means no automatic statement sync. That's the main thing moneasy doesn't do. CSV import from your bank is the available workaround, but it's a manual step.

We could have added a third-party aggregator and solved it. We didn't, because it would have undermined the whole premise. Some users keep waiting for the "connect your bank" screen that never comes — that's the main UX confusion we're still working through.

What we noticed shipping it

Receipt OCR works well on most printed receipts; faded thermal paper is the edge case that still misses occasionally. Voice input accuracy is high once the Siri shortcut is set up, but first-time configuration has friction we're reducing.

¥450/month or ¥5,000/year, 30-day trial included.

https://apps.apple.com/jp/app/moneasy/id6742516728

We let users record their own shutter sound. Here's what that opened up.

niixolabs — Mon, 25 May 2026 23:03:53 +0000

The shutter sound no one questions

Your phone has made the same click since you unboxed it. Nobody asks why. It's just there — the sound that says a photo happened.

We started wondering what would change if that sound were yours to define.

What Voicame does

Voicame (ボイカメ) is a camera app that lets you record any audio and use it as the shutter. A child's name. A word you like. A short phrase. When you tap the shutter button — or use the hardware camera button on supported iPhones — that recorded sound plays instead of the default click.

The idea came from a specific frustration: trying to photograph young children who flinch at unfamiliar sounds, or who don't look up unless their name is called. If the shutter trigger plays their own name, they turn toward it.

Alongside the voice shutter, six symmetry modes preview live as you frame: horizontal, vertical, diagonal, quad, kaleidoscope, and swirl. They work for photos and for video recording. Recorded sounds can export via AirDrop.

Under the hood: AVFoundation for capture and recording, CoreImage's CIKaleidoscope filter for symmetry, Metal for real-time preview, AVAssetWriter for video output, AVCaptureEventInteraction (iOS 17.2+) for hardware shutter button integration. Fully on-device — nothing uploaded.

Where it falls short

Being direct: symmetry cameras are not an unusual category. Kaleidoscope-style apps have existed for years, and we're not pretending otherwise. Voicame's argument is that tying voice shutter and live symmetry together in one workflow is a specific enough combination to be worth shipping.

Gaps: iOS-only, no Android, no Apple Watch. Shutter sound volume is controlled by the device's media volume — no independent control.

Availability

Free to download. One-time ¥250 in-app purchase for all six symmetry modes. No subscription.

https://apps.apple.com/jp/app/id6768058856

We built a puzzle game about noticing the one thing that's wrong

niixolabs — Sat, 23 May 2026 23:04:30 +0000

There's a specific kind of satisfaction in noticing something is wrong before you can explain why.

You're looking at a grid of geometric shapes. Each one appears identical. But one isn't — something in the rotation, the scale, the position is fractionally off. The moment you see it, you can't unsee it.

That's the experience we were after when we built Off By One.

What we were trying to solve

Most puzzle games ask you to be fast, or to remember things, or to react. We wanted to build something that rewarded sustained attention instead — the kind of calm, patient looking you do when you're proofreading or checking a design for alignment errors.

Off By One strips everything else away. No timer running in the corner. No score multiplier. No story. Just a grid and a small wrongness hiding inside it.

How the puzzles are generated

We use SwiftUI's Canvas API for rendering. Shape type, decoration pattern, and placement are combined procedurally — about 133,200 possible combinations. The practical effect: replaying a stage rarely gives you the same puzzle twice, which matters for a game with no narrative carrying you forward.

Three difficulty levels across 35 stages. On Easy, the off element is clearly different. On Hard, you're looking for a rotation difference that's genuinely subtle — the kind that makes you second-guess yourself before you commit. Game Center tracks progress with 17 achievements.

Honest limitations

The 6-second App Store preview video is a real problem for us. "Quiet observation" doesn't compress into a clip. We've watched people look at the preview and not understand what the game is — a legitimate discovery issue we haven't solved.

We also haven't implemented in-app purchase. The app is free with rewarded ads only, which means users who genuinely love it have no way to pay for an upgrade. That gap is on us.

Who it's for

People who want five minutes of calm focus between tasks. People who like finding things. People who find countdown timers stressful.

Free on iOS 16+. Published by Niixo Labs.

App Store

We built a mahjong dangerous-tile predictor calibrated on 4.97M real hands

niixolabs — Fri, 22 May 2026 23:04:30 +0000

The problem

At a real mahjong table, software can't help you mid-hand. The question — "is this tile safe to discard?" — comes up every few turns, and you work it out from memory and pattern recognition alone.

We wanted something you could set next to you at the table, pick up in a second, and put down without disrupting the game.

What OkkanaiPai does

Three interactions:

Swipe to select the player you want to read
Tap their discarded tiles to enter them
See all 34 tiles color-coded by danger level

The whole flow is designed to be glanceable — you're not staring at a screen mid-game.

The model behind it

We didn't ship a live inference model. Instead, we calibrated a rule-based system against 4.97 million discards from Tenhou's Houou-takujo server (the top competitive tier), covering 16 days of logged play.

The result is a set of coefficients stored as JSON inside the app. AUC on held-out data came to 0.83. Not perfect, but statistically meaningful for a glance-level judgment call at the table. Everything runs fully offline — no network request, no account, no subscription.

What it doesn't cover

Being upfront about scope:

Calibration is East-round / East-seat data. Accuracy may degrade in South-round play.
Meld efficiency — how chii, pon, or kan reshapes hand danger — is not modeled.
Three-player mahjong (sanma) is not supported.

For standard 4-player East-focused games, it fits. Outside that, weight the output accordingly.

Why build it

Niixo Labs is running a sprint: small, focused iOS tools, shipped fast. OkkanaiPai explores what "calibrated statistics as UX" looks like in a game-assistance context — where a lightweight, offline coefficient table can deliver meaningful signal without any server infrastructure. Free, no ads, no IAP.

https://apps.apple.com/jp/app/id6762544982

We built a weather app that stops pretending everyone feels the same temperature

niixolabs — Thu, 21 May 2026 23:04:05 +0000

Most weather apps answer the wrong question.

They tell you it's 12°C outside. That's accurate. But whether 12°C means you need a coat depends entirely on who you are — and weather apps don't know you.

That friction is what Samukunai ('Are You Cold?') is built around.

How it works

The mechanic is minimal: tap warm or cold after you check the morning forecast. That's the only input you give the app.

After 10 of those taps, Samukunai calculates your personal cold threshold using 75th/25th percentile statistics on your own feedback data. Once calibrated, the morning push notification shifts from a generic temperature to something like "on the cold side for you" — not a city average.

No machine learning. Nothing trained on external datasets. The personalization is your data — full stop. That was a deliberate choice; it keeps the logic auditable and the scope narrow.

Stack

WeatherKit handles weather data. SwiftData + CloudKit sync feedback across devices. The personalization logic lives in a module we call ComfortEngine — it's statistics, not a model. The UI follows iOS 26 Liquid Glass conventions.

What we got wrong

The cold-start problem is real. Below 10 feedbacks, Samukunai is a worse weather app than the one that came with your phone. No personalization, less information, no widget.

We knew that going in and shipped anyway, because the core loop — tap, accumulate, personalize — needed real users to validate. iOS 26+ only makes the addressable market smaller too. We're not pretending otherwise.

Who it's for

If you run cold, if you overdress every spring, or if you're the person who always asks "do I need a jacket?" — give it 10 taps. That's the buy-in.

Free. No ads. No in-app purchases.

App Store

We built a leg-fidget counter. Here's what that actually took.

niixolabs — Wed, 20 May 2026 23:03:16 +0000

The problem nobody is measuring

Non-Exercise Activity Thermogenesis — NEAT — is the energy your body burns doing everything that isn't deliberate exercise. Fidgeting is a big part of it. Levine's research puts the gap between high and low fidgeters at 350 kcal/day. That's a real difference.

The problem: nobody knows how much they actually fidget. There's no baseline. We decided to build one.

What BinBot does

BinBot runs in the background on iPhone and Apple Watch and counts your leg movements across the day — three modes: shakes, jumps, rotations. It writes everything to HealthKit so the count lives in your health timeline alongside steps and sleep. A Live Activity and home screen widget keep the running total visible without opening the app.

The part that took the most time

We sample at 100Hz via CoreMotion and run the signal through an IIR bandpass filter at 3–9Hz. That frequency band is where leg fidgeting lives; walking and car vibration sit mostly outside it. In theory.

In practice, the edge cases are the hard part. Fast walking, rough roads, and certain seated movements can leak into the detection range. We use a five-layer rhythm classifier on top of the filter to reduce that noise, but false positives still happen occasionally. We document this honestly.

The other known limitation: Watch-to-iPhone sync is currently one-directional. The Watch logs independently and pushes to iPhone, but not the reverse.

Takeaway

Chasing perfect accuracy in motion sensing is a trap. We ship it as a trend tool — the day-over-day pattern matters more than any single count being precise.

Free, ad-supported. No paywall.

https://apps.apple.com/jp/app/id6760091302

What we built to help cat owners answer 'when did this start?'

niixolabs — Tue, 19 May 2026 23:05:49 +0000

Every first-time kitten owner eventually faces this: the vet asks "when did you first notice that?" and you draw a blank. Not from carelessness — just from never being prompted to track.

That's the problem Nekososdate was built around.

The core mechanic

Register your kitten's birthdate. From that point, care guidance arrives automatically, calibrated to your cat's current age. What matters at week 3 is not what matters at month 4. We built 54 guides to cover the phases new owners find most confusing, structured as a timeline rather than a static FAQ.

What else is in the app

48 troubleshooting topics — a reference for "is this normal?" moments
34 breed profiles — overview of traits and tendencies by breed
15-question temperament diagnostic — focused on how this specific cat behaves, not just breed

The records and logs are really what the app is about. The guides teach; the records give you something concrete to bring to the vet.

Stack and content model

Flutter frontend, Firebase, StoreKit 2 for subscriptions. Content ships as asset-bundled JSON — no network dependency at read time. That keeps it usable in places without signal, which matters in vet waiting rooms.

Free to download. All 54 guides unlock for ¥200/month.

What it doesn't do

iOS only — no Android build. No family sharing. Two people raising a kitten together can't sync records across devices. It's a real gap and one we know about.

Why we shipped it

Small, focused tools tend to outlast ambitious ones. A kitten care guide that's genuinely useful for the first year of ownership is enough scope for a first version.

Nekososdate on the App Store

We shipped an on-device Japanese braille reader — here's why offline-first was non-negotiable

niixolabs — Mon, 18 May 2026 23:05:10 +0000

The problem sitting in plain sight

There's braille on train handrails, elevator buttons, and pill boxes all over Japan. Most people walk past it every day without a second thought — not because they don't care, but because almost nobody can read braille.

TenjiScan is our attempt to close that gap. Point your iPhone camera at any Japanese braille, get plain text back. That's the whole pitch.

Why we went fully offline

The first architectural decision we locked in was: no server. Braille appears on medication packaging, medical devices, banking equipment — contexts where sending someone's photo to a remote endpoint feels like a bad trade. It's not worth the privacy exposure.

Since v4.0.0, all recognition runs through a custom two-signal pipeline built on Vision. No network required, no image leaves the device. The trade-off is that we own the accuracy ceiling entirely — no external model updates — which pushes us to get the on-device pipeline right rather than lean on infrastructure.

What it actually supports

The app handles JIS Japanese braille (the national standard, JIS T 0921) and UEB Grade 1 English braille. Grade 2 contracted English braille isn't supported yet — contracted braille compresses text using shorthand symbols, and it's a meaningful gap for English-speaking users who depend on it in practice. We know. It's on the list.

The honest limitation

Lighting and shooting angle matter. Braille bumps cast shadows that make recognition possible, which means flat, even light actually hurts accuracy. We added UI guidance to help users find better angles, but in poor lighting the recognition still struggles. This isn't buried in fine print — it's just physics.

What surprised us

The use case we didn't fully anticipate: sighted people who are simply curious. Someone picks up a pill box they've owned for years and finally reads the braille on it. The app makes a small part of the tactile world readable without requiring expertise, and accessibility users have told us the on-device guarantee matters more to them than raw recognition speed.

TenjiScan is free on the App Store, with a one-time purchase to remove ads.
https://apps.apple.com/jp/app/id6759526188

Musubiba: Making Neighborhood Association Workload Visible

niixolabs — Sun, 17 May 2026 23:04:43 +0000

Running a Japanese neighborhood association — jichikai or chonaikai — involves a surprisingly dense set of recurring tasks: circulating bulletins to every household, collecting annual dues, conducting safety checks on elderly residents, managing votes at the general meeting, maintaining a shared annual calendar, and writing handover documentation for whoever takes over next year.

Most of this gets handled across paper forms, LINE group chats, and verbal hand-offs. Nobody holds a complete picture of who is doing how much, and that invisibility is a core reason these positions are perpetually hard to fill.

Musubiba is our attempt to address that specific problem.

The app isn't trying to automate volunteer work — the goal is visibility. When every task is logged in one place, workload distribution becomes data instead of assumption. A new officer inheriting the role can open structured handover notes instead of piecing things together from memory.

The feature set covers exactly what the job requires: bulletin circulation with per-household tracking, dues collection, safety check logs, meeting votes, an annual schedule, and handover notes. Members join by scanning a QR code. There's also a web view for accounting entry, which we added because many officers are more comfortable entering financial data at a keyboard.

Tech stack: Flutter for the shared iOS/Android codebase, Firebase (Firestore, Auth, Cloud Functions) for backend, Stripe plus Apple IAP for payments.

One thing worth being upfront about: Musubiba is built specifically for Japan's jichikai/chonaikai structure. The terminology, flows, and assumptions reflect how Japanese neighborhood associations actually operate. It won't map cleanly to HOAs or similar organizations outside Japan — that's an honest scope limit, not an oversight.

Pricing: free for groups up to 15 members. Unlimited membership costs ¥1,500/month.

App Store: https://apps.apple.com/jp/app/musubiba/id6759871374

Google Play: https://play.google.com/store/apps/details?id=com.htor.musubiba

We built a finance app that refuses to ask for your bank login

niixolabs — Sat, 16 May 2026 23:03:01 +0000

The problem with most expense trackers

Most personal finance apps assume you'll hand over your bank credentials. The whole UX is designed around that assumption: connect your account, pull your transactions, done. That's a valid model — but there's a real subset of users who have made a deliberate choice to never give an OAuth token for their bank account to a third-party service.

moneasy was built for those users.

How logging works

Two paths. Say "moneasy 記録" to Siri and the voice input goes through Apple Speech. Or hold the camera up to a receipt — Vision OCR reads it, and Gemini 2.5 Flash handles the messier cases: Japanese receipts especially have abbreviations and format variations that need a language model to interpret reliably. Either way, the entry lands in SwiftData and syncs across devices via CloudKit.

The interaction is a few seconds. No account-linking screen, no permissions beyond camera and microphone.

The trade-off we're upfront about

No bank API means no automatic statement import. We say this plainly in the App Store description — surprising users with a limitation they care about is a worse outcome than losing them at the listing. CSV import is available for bulk historical data.

For the user who has never connected a bank account to any third-party app, the absence of that feature is the point of the app.

What ships

Voice input via Apple Speech + receipt OCR via Vision, with Gemini 2.5 Flash for parsing edge cases
SwiftData + CloudKit sync
25 language support
30-day free trial, then ¥450/month or ¥5,000/year

Finance is a crowded category. The wedge is narrow: voice input paired with a deliberate refusal to touch bank credentials.

moneasy on the App Store