DEV Community: Goksel Yesiller

Introducing Advanced Markdown Previewer: A Quick Tour

Goksel Yesiller — Sun, 21 Jun 2026 14:19:26 +0000

Documentation workflows fracture when Markdown content needs precise rendering checks. Developers and technical writers waste cycles toggling between source editors and preview tools, breaking concentration and slowing iteration. A single environment that renders complex Markdown in real time eliminates that friction.

What it is

The Advanced Markdown Previewer is a browser-based editor with a split-pane layout: source on the left, live preview on the right. It renders Markdown instantly as you type. It supports the full GitHub Flavored Markdown (GFM) specification—including task lists, tables, and autolinks—alongside LaTeX-style mathematical expressions via KaTeX and syntax-highlighted code blocks across dozens of languages. Raw HTML embedding is supported, and external link behavior is configurable. The tool also tracks document statistics such as word count and character count in real time.

The previewer is one of 200+ free browser tools on DevTools, operating entirely client-side. No signup, no tracking—content never leaves the browser, making it suitable for proprietary or sensitive documentation drafts.

How to use it

Open the tool to see the dual-pane interface. Paste existing Markdown into the left editor or start writing from scratch. The preview updates immediately, reflecting GFM extensions and any math or code blocks.

For inline math, wrap LaTeX in single dollar signs: $E = mc^2$ . Display math uses double dollar signs:

$$
\int_{-\infty}^{\infty} e^{-x^2} dx = \sqrt{\pi}
$$

Code blocks with language identifiers get syntax highlighting. Example:

function fibonacci(n) {
  if (n <= 1) return n;
  return fibonacci(n - 1) + fibonacci(n - 2);
}

A settings panel lets you toggle GFM features, math rendering, HTML support, and link behavior. You can load sample documents to explore formatting, and export the rendered output as HTML. Real-time statistics—word count, character count—help when you’re working against length constraints.

When to reach for it

Use this tool when you need an accurate, zero-latency preview of Markdown destined for GitHub, GitLab, or similar platforms. It’s particularly valuable for documentation that mixes prose with mathematical notation, such as API specs involving formulas, academic papers, or engineering design documents. The KaTeX rendering matches what you’d see in many static site generators and notebook environments.

Technical writers preparing release notes, README files, or internal specs benefit from the side-by-side view during collaborative reviews, where both source and rendered output must be visible. The statistics panel aids content planning when you’re targeting a specific word count. And because the tool processes everything in the browser, it’s safe to use with confidential material without routing through a server.

Compared to a local editor’s Markdown preview plugin, this tool offers a dedicated, distraction-free environment with GFM and math support that may not be available in your IDE. It also serves as a quick validation step before pushing documentation to a repository.

Try it yourself

The Advanced Markdown Previewer is available at https://devtools.tools/markdown-previewer. It runs entirely in the browser. Try it in about 30 seconds—paste a README or a math-heavy document to see the rendering.

Related tools

Markdown Table Generator – Build properly aligned Markdown tables with a visual editor, then copy the formatted output directly into your documents.
GitHub README Generator – Assemble a complete README with project badges, installation instructions, and structured sections tailored for GitHub repositories.

Together, these tools streamline the documentation pipeline from drafting to final formatting.

Try it: Advanced Markdown Previewer on DevTools

Introducing AES Encryption: A Quick Tour

Goksel Yesiller — Sun, 21 Jun 2026 14:16:20 +0000

Developers implementing client-side encryption face a fundamental challenge: correctly implementing AES encryption requires deep knowledge of key derivation, initialization vectors, and authentication tags. One mistake in parameter selection or implementation can compromise the entire security model. The AES Encryption tool addresses this by providing a reference implementation that handles the cryptographic complexity while keeping sensitive data entirely within the browser.

Why it stands out

Most encryption tools fall into two problematic categories: server-based services that require trusting a third party with your plaintext, or complex libraries that require significant integration work. This tool occupies a unique position — it implements proper AES-GCM encryption with PBKDF2 key derivation using only the Web Crypto API, demonstrating how to build secure encryption without external dependencies.

The implementation choices reflect current cryptographic best practices: AES-GCM for authenticated encryption, PBKDF2 with 100,000 iterations for key stretching, and proper random generation for salts and initialization vectors. As one of 200+ free browser tools on DevTools, it operates with no signup, no tracking — data processed entirely in the browser.

What it is

The AES Encryption tool implements AES-256-GCM encryption with PBKDF2 key derivation through the Web Crypto API. The tool generates cryptographically secure random values for salts and initialization vectors, derives encryption keys from passphrases using PBKDF2-HMAC-SHA256, and produces self-contained encrypted outputs that include all parameters necessary for decryption.

The architecture ensures that plaintext, passphrases, and derived keys exist only in browser memory. The Web Crypto API provides the underlying cryptographic primitives, leveraging the browser's native implementation for both security and performance.

How to use it

The interface exposes two operations: encryption and decryption. For encryption, enter plaintext and a passphrase. The tool generates a 16-byte salt and 12-byte initialization vector using crypto.getRandomValues(), then derives a 256-bit key:

// Key derivation process
const salt = crypto.getRandomValues(new Uint8Array(16));
const iv = crypto.getRandomValues(new Uint8Array(12));

const keyMaterial = await crypto.subtle.importKey(
  "raw",
  encoder.encode(passphrase),
  "PBKDF2",
  false,
  ["deriveKey"]
);

const key = await crypto.subtle.deriveKey(
  {
    name: "PBKDF2",
    salt: salt,
    iterations: 100000,
    hash: "SHA-256"
  },
  keyMaterial,
  { name: "AES-GCM", length: 256 },
  false,
  ["encrypt", "decrypt"]
);

The encryption operation produces a base64-encoded output containing the salt, IV, and ciphertext with authentication tag. This self-contained format ensures portability — the encrypted data includes everything needed for decryption.

For decryption, paste the encrypted output and provide the original passphrase. The tool parses the embedded parameters, re-derives the key using the same PBKDF2 process, and attempts decryption. Failed authentication (wrong passphrase or tampered data) results in a clear error.

When to reach for it

Several scenarios benefit from browser-based AES encryption. During development of applications with client-side encryption requirements, the tool serves as a reference for proper implementation patterns. Developers can encrypt test data, configuration values, or API keys without installing additional software.

For debugging encryption-related issues, the tool provides a known-good implementation to verify expected outputs. When an application's encryption produces unexpected results, developers can use this tool to isolate whether the issue lies in their key derivation, encryption parameters, or data encoding.

The tool also functions as an educational resource. Developers new to Web Crypto API can examine a working implementation of AES-GCM with proper key derivation, understanding how the pieces fit together before implementing similar functionality in their applications.

Security auditors and penetration testers find value in quickly encrypting payloads or decrypting intercepted data during assessments, particularly when working with applications that implement similar AES-GCM schemes.

Technical implementation details

The tool demonstrates several cryptographic best practices. PBKDF2 iteration count is set to 100,000 — a balance between security and browser performance. The 96-bit IV size aligns with GCM mode recommendations. Salt generation uses cryptographically secure randomness, ensuring unique key derivation even with password reuse.

Error handling distinguishes between different failure modes: invalid base64 encoding, missing parameters, and authentication failures each produce specific error messages. This granular feedback helps developers debug integration issues with their own implementations.

The output format uses a simple concatenation scheme: base64(salt || iv || ciphertext). While not a standard format like JWE, this approach minimizes complexity while maintaining all necessary decryption parameters.

Try it yourself

The tool is available at devtools.tools/aes-encryption. It runs entirely in the browser and takes about 30 seconds to encrypt your first piece of data. No installation, no account creation, no data leaves your device.

Related tools

Base64 Encoder/Decoder: Convert between text and base64 encoding for data transmission
HMAC Generator: Create Hash-based Message Authentication Codes for message verification
UUID Generator: Generate cryptographically secure UUIDs for unique identifiers

P.S. If you're implementing client-side encryption in your own applications, consider this tool a baseline for comparison. The Web Crypto API makes secure encryption accessible — the challenge lies in getting the details right.

Try it: AES Encryption on DevTools