Онлайн-блокнот

A free online notepad that autosaves in your browser

This online notepad is a fast, distraction-free place to write — notes, drafts, lists, code snippets, anything. There's nothing to install and no account to create: open the page and start typing. As you write it autosaves to your browser, so your text is waiting for you next time with no Save button to remember.

It's a genuine free online notepad with a full editor — adjustable font size, a monospace mode for code, optional word wrap, and a live counter for words, characters, lines and reading time — wrapped in a clean, responsive layout that works just as well on a phone as on a desktop.

Your notes stay private — stored locally, never uploaded

Most online notepads quietly save what you type to their server. This one doesn't. Every note is kept in your browser's localStorage on your own device, so nothing is ever uploaded, logged or shared. That makes it a safe scratchpad for meeting notes, passwords-in-progress, personal journaling or confidential drafts you'd rather not put into a cloud app.

Because the notepad is fully client-side, it also works offline: once the page loads it makes no further network calls, so you can keep writing with no connection and your notes still save locally.

Dark mode and a comfortable, focused editor

Flip on dark mode for a dark writing surface with light text — much kinder to your eyes at night — and the notepad remembers your choice. Bump the font size up or down, switch to a monospace font when you're pasting code, and toggle word wrap depending on whether you're writing prose or wide log lines.

The editor is intentionally minimal so the words come first, while the toolbar keeps the controls you actually reach for — theme, type size, copy, download and password — within a click on every screen size.

Password-protect notes with on-device encryption

Need an encrypted notepad? Add a password to any note and it's encrypted with AES-256-GCM using a key derived from your passphrase via PBKDF2 (150,000 iterations and a random salt) — all through the browser's built-in Web Crypto API. Only the encrypted blob is written to localStorage; the plain text never touches disk, and the passphrase is never stored or sent anywhere.

This is the feature server-based notepads can't honestly offer: an online notepad with password protection where the encryption happens entirely on your machine. Evernote, Google Keep and Notion store your notes on their servers and have no client-side encryption. The trade-off here is that there's no password reset — if you forget the passphrase, the note can't be recovered, so pick one you'll remember.

How it compares to Evernote, Notion and Google Keep

Evernote's free plan caps you at two devices, 60 MB monthly upload and 25 notes per month. Notion's free plan requires an account and limits block count. OneNote demands a Microsoft account. Google Keep stores everything on Google's servers and scans content for its ad and AI systems. All four require internet access to sync. This notepad online has no device limit, no upload cap, no account and no server. It runs in your browser, stores data in your localStorage, and works offline.

The trade-off is that you can't share live links or sync across devices without exporting manually. If real-time collaboration is what you need, Notion or Google Docs are better fits. If you want a fast, private scratchpad that opens instantly and doesn't ask for your email, this is it.

No sign-up, no limits, just a notepad online

There's no login, no email and no cost. This simple online notepad opens instantly and saves automatically, making it perfect for quick thoughts, to-do lists, drafting messages or jotting down a number before you forget it. Bookmark it and you've got a reliable notepad online for whenever you need to write something down — private by default, and always one tab away.

How browser storage actually works: localStorage vs sessionStorage

Browsers expose two storage mechanisms through the Web Storage API: localStorage and sessionStorage. Both store key-value string pairs per origin (protocol + domain + port), but they differ critically in lifetime. sessionStorage is wiped the moment you close a tab — it exists purely for temporary, in-session state. localStorage persists indefinitely until the user clears site data or the site itself removes a key, which is exactly why this notepad uses it: close the tab, restart the computer, come back a week later and the note is still there.

The storage quota is set by each browser rather than the web standard, but the practical ceiling is 5–10 MB per origin. Chrome, Edge and Firefox typically grant 5 MB of string data per origin; Safari is stricter. For plain text that is enormous — a 5 MB limit holds roughly 2.5 million words of prose — so you are unlikely to hit it with notes. One important limitation is that both APIs are synchronous: a read or write blocks the browser's main thread until it completes. For tiny payloads like text notes this is imperceptible, but sites that store large objects in localStorage can cause janky scroll and input lag. Modern applications that need async storage use the IndexedDB API instead, which works in background threads.

From a security perspective, any JavaScript running on the same origin can read localStorage — which means a cross-site scripting (XSS) vulnerability would expose every stored key to an attacker's injected script. This is why sensitive credentials should never be stored in localStorage unencrypted. The password-protected notes in this notepad address exactly that risk: only an AES-256-GCM ciphertext is written to storage, so even a hypothetical XSS attack would retrieve an unreadable blob rather than your raw text.

Plain text, rich text, and word processor formats — what actually differs

Plain text (encoded as ASCII or UTF-8) is the simplest possible format: a sequence of characters with no embedded formatting. Every operating system, every editor, every terminal can open a .txt file without knowing anything about the program that created it. A five-letter word like 'Hello' stored as plain text occupies exactly 5 bytes. That same word inside a .docx file — Microsoft's Office Open XML format introduced in Word 2007 — arrives wrapped in roughly 10 kilobytes of ZIP-compressed XML, relationship manifests, theme definitions and content-type declarations. The apparent 'Hello' document is actually a ZIP archive containing a folder tree. This is not waste for its own sake; .docx encodes pagination, fonts, embedded images, change-tracking and review comments. But it means the format is fragile: opening a .docx in anything other than Word or a compatible application risks mangled layout.

Rich Text Format (RTF) was Microsoft's 1987 attempt at a portable middle ground — bold, italic, colour and font metadata encoded as plain ASCII escape sequences that any text editor could at least display as readable (if messy) characters. RTF solved the cross-application problem for basic formatting and is still used today as the default copy-paste format on Windows. The binary .doc format that preceded .docx stored formatting in a proprietary binary structure that was notoriously difficult for third-party developers to reverse-engineer, contributing to years of interoperability problems between Word and competing office suites.

Developers almost universally prefer plain text because it works cleanly with version control: Git can diff two versions of a plain-text file line by line and show exactly what changed. A change to one sentence in a 50-page .docx produces an opaque binary diff that reveals nothing about what was actually edited. Markdown — plain text with lightweight punctuation for headings, bold and links — sits in a practical sweet spot: it is human-readable in its raw form, diffs perfectly in Git, and converts to formatted HTML, PDF or Word with a single command. That is why technical documentation, README files, and a growing share of personal note-taking have migrated from word processors to Markdown in plain text files.

A brief history of the text editor

The lineage of the text editor starts before computers had screens. The Wang Word Processing System (1976) was one of the first dedicated word processors: a proprietary workstation with a CRT display that let secretaries edit text before printing it — a transformative shift from typewriters, where a correction meant retyping a page. WordStar (1978) brought word processing to the CP/M microcomputer and introduced the Ctrl-key chord shortcuts that still live in many editors today. WordPerfect (1982) dominated the DOS era with its Reveal Codes view, and Microsoft Word (1983) arrived first on the Mac, using the mouse-driven interface that would eventually become the industry standard.

On Unix, two editors emerged in 1976 that remain in daily use fifty years later. vi, written by Bill Joy at Berkeley, established the principle of modal editing: the editor has distinct modes for navigation and for inserting text, so the home-row keys become navigation commands in normal mode. Its successor, Vim (Vi IMproved, 1991), extended this model into a programmable editor with syntax highlighting and plugins. GNU Emacs, created by Richard Stallman in 1976 and re-implemented in 1984, took a different philosophy: rather than modes, everything is a keyboard-bound Lisp function, making Emacs extensible to the point where users run email, a file manager, a calendar and a web browser inside the editor — giving rise to the joke that Emacs is a great operating system that lacks a decent editor.

Microsoft's Notepad shipped with Windows 1.0 in 1985 as a barebones text editor deliberately stripped of formatting — a tool for editing config files, not writing documents. For over three decades it went essentially unchanged: single-level undo, no syntax highlighting, no line numbers. In 2018, Microsoft finally updated Notepad for Windows 10 with multi-level undo, Unix line-ending support and a zoom control. The enduring popularity of a program that did so little for so long is itself a statement about the value of a fast, zero-ceremony plain-text editor.

The privacy trade-offs of cloud note-taking

Cloud-based note applications are convenient — your notes follow you across every device — but that convenience comes with a privacy cost that is easy to underestimate. In 2016, Evernote updated its privacy policy to allow employees to read user notes for machine-learning quality review, reversing the change only after public backlash. The notes were never 'public', but they were accessible to the company's infrastructure and staff. Smaller note-sync startups have sold anonymised usage data as a revenue stream, and 'anonymised' datasets of personal writing are notoriously difficult to truly de-identify. When a company stores your notes, the risk surface includes the company itself, any breach of its servers, law-enforcement requests, and future changes to its business model or ownership.

A growing category of end-to-end encrypted (E2EE) note apps addresses this directly. Standard Notes encrypts every note on-device before transmitting it, so the server stores only ciphertext it cannot read. Notesnook takes a similar approach with open-source clients and independently audited cryptography. With E2EE, even if the company's servers are breached or subpoenaed, the attacker retrieves nothing but encrypted blobs. The trade-off is that the company also cannot help you recover a forgotten encryption passphrase, and some features — full-text search across devices, real-time collaboration — are technically harder to implement on ciphertext.

A browser-local notepad like this one takes the most conservative position: nothing is transmitted at all, so there is no server to breach and no company with access to your text. Your notes are as private as your own device. The trade-off is the absence of cross-device sync — notes written on one browser stay on that browser unless you export them manually. For users whose primary concern is keeping personal writing, sensitive drafts or confidential ideas away from third-party servers, a locally stored, optionally encrypted notepad is the most straightforward guarantee of data ownership available in a web browser.