Floating sticky notes that sit on your Windows desktop, controlled entirely from a tray icon next to the clock. Colors, always-on-top pinning, rich text, a restorable trash, autosave, and start-with-Windows.

Written in C# / WPF on .NET 10 with a local SQLite database that lives next to the executable. That last part is the whole point.

Built with AI. Every feature here was planned, implemented and tested in sessions driven by OpenCode and the DeepSeek v4 Flash (FREE) model. This is stated up front so you know what you are reading before you review it or build on it.

Most "portable" note apps still write to %AppData%. This one does not:

• notes.db — the SQLite database, in the executable's folder.
• prefs.json — the preferences, in the executable's folder.

Copy the folder to a USB stick and your notes travel with it, exactly as they were: text, formatting, color, shape, pin state, opacity, font size, position and size. Nothing is left behind on the machine you copied it from.

The flip side is worth saying out loud: delete the folder and you delete your notes. Always move the data with the app.

There is no main window. Everything runs from the amber icon next to the clock.

• Drag by the title bar, resize from the edges — Windows snap works.
• Pin it always-on-top with the 📌 button or the context menu.
• Color: the 🎨 button cycles the palette; the context menu picks from all seven.
• Shape: square or Windows 11-style rounded corners, saved per note.
• Title: the field in the window bar. It becomes the note's label in the tray, in the list and in the window; when empty, the note's text is used instead.
• Formatting: bold, italic, bullets and font size (9–26), with Ctrl+B and Ctrl+I. It is stored as RTF and travels with the note.
• Opacity: 100% down to 20% from the context menu.
• Closing a note hides it; it stays saved and comes back from the tray.
• Deleting moves it to the trash, with confirmation. Restoring is a double click. Permanent deletion and emptying the trash are separate, explicit actions.

Everything autosaves 500 ms after you stop typing. Reopen the app and every note is exactly where you left it.

Opções… › Iniciar com o Windows writes a value under HKCU\Software\Microsoft\Windows\CurrentVersion\Run. No installer, no service, no scheduled task. Mostrar notas ao iniciar decides whether the notes appear or the app starts quietly in the tray.

One NuGet package in total. That is not an accident, and pull requests that add more will be asked to justify themselves.

The project is a single WPF assembly organized in layers, so the domain does not know the UI exists:

src/
  App.xaml(.cs)                    composition root: wiring and lifecycle
  Domain/Notes/                    pure domain, no UI dependency
    Note.cs                        the entity: data, touch, snippet
    NoteShape.cs                   window shapes (square/rounded) + normalization
    Palette.cs                     the seven colors
  Application/                     use cases and contracts
    Contracts/INoteRepository.cs   repository interface (DIP)
    Contracts/IPreferencesStore.cs preferences interface
    Notes/NoteService.cs           rules: create, trash, restore, purge
  Infrastructure/                  concrete implementations
    Persistence/NoteRepository.cs  SQLite, debounced autosave, legacy migration
    Persistence/PrefsRepository.cs prefs.json, with a legacy fallback
    Persistence/AppPaths.cs        paths resolved relative to the executable
    Runtime/HotkeyService.cs       Ctrl+Alt+N (Win32)
    Runtime/AutostartService.cs    the Run registry value
  Presentation/                    everything visible
    Host/NoteManager.cs            coordinates windows, calls NoteService
    Tray/TrayService.cs            tray icon and menu
    Tray/IconFactory.cs            icon drawn in code (fallback)
    Windows/NoteWindow.*           the floating note
    Windows/NotesListWindow.*      the note list
    Windows/TrashWindow.*          trash: restore, delete, empty
    Windows/SettingsWindow.*       options
    Windows/AboutWindow.*          about
scripts/
  build.ps1                        plain publish (or portable with -Portable)
  run.ps1                          test publish into dist\MyOpenPins-test, then run
  release.ps1                      portable publish into dist\MyOpenPins-portable + zip

Requires the .NET SDK 10 (10.0.x) on Windows.

git clone https://github.com/claudneysessa/my-open-pins.git
cd my-open-pins

.\scripts\run.ps1        # test build into dist\MyOpenPins-test, then launch
.\scripts\release.ps1    # portable build into dist\MyOpenPins-portable + .zip

During development, dotnet build src\MyOpenPins.csproj -c Release should finish with 0 errors and 0 warnings. That is the bar, not an aspiration.

• Notes: notes.db (SQLite), in the executable's folder.
• Preferences: prefs.json, in the executable's folder — it will read an old %AppData%\ClonePNotes\prefs.json once if it finds one.
• Migration: on first run, a legacy notes.json (either next to the exe or in %AppData%\ClonePNotes) is converted into the database.

A corrupt database does not take the app down. Only one instance runs per user, guarded by a mutex.

Honest list, each one an open door rather than an excuse:

• Windows only. WPF, the tray API and the registry autostart are all Windows-specific.
• One instance per user, enforced by a mutex.
• The hotkey is fixed at Ctrl+Alt+N. Making it configurable is on the roadmap.
• No alarms or timed reminders. Deliberately out of scope so far, and the most requested next feature.
• The interface is Portuguese only. Menus and dialogs read Nova nota, Lixeira, Opções, as the screenshot shows. Localizing is an open task and a good first contribution.
• No automated tests. The domain layer (NoteService, NoteShape, Palette) is pure and genuinely testable, which makes it the obvious place for a first real test project.

1. Alarms with a tray notification.
2. A configurable hotkey in Opções….
3. Export and import notes as .txt.

Contributions are welcome — bugs, features, documentation and ideas. Read CONTRIBUTING.md first: it covers the code language convention (identifiers in English, user-facing text in Portuguese), the one-package rule, the commit-per-step convention and the manual test checklist. Participation is covered by the Code of Conduct, and security reports have their own policy.

Author: Claudney Sarti Sessa — Senior Developer · claudneysartisessa@gmail.com · LinkedIn · GitHub

Built with OpenCode and the DeepSeek v4 Flash (FREE) model.

Icons — used under Flaticon's CC 3.0 BY terms, attribution required and given:

• App and tray icon: note icons created by Pixel perfect — Flaticon
• bold icons created by Magnific — Flaticon
• italic icons created by Magnific — Flaticon
• list icons created by Aldo Cervantes — Flaticon
• font size icons created by Md Tanvirul Haque — Flaticon

The MIT License covers the code in this repository. The icons above keep their own Flaticon license, and Microsoft.Data.Sqlite keeps its own.