2026-04-24 19:20:46
For many of us who spend significant time interacting with our Macs, the desire for more efficient text input methods is a constant. Whether it's drafting quick notes, documenting intricate code, or filling out repetitive forms, the act of typing can sometimes feel like a bottleneck. While macOS provides a built-in dictation feature, its accessibility isn't always optimal, often requiring users to remember specific, sometimes cumbersome, keyboard shortcuts.
This is precisely the problem that PinDrop seeks to solve. As an open-source project, PinDrop offers a compelling alternative and a significant enhancement to the native macOS dictation experience. It's designed from the ground up to be seamlessly integrated into your workflow, promoting a more intuitive and fluid approach to text entry across a wide array of applications.
PinDrop isn't just another utility; it's a thoughtfully designed tool aimed at developers, content creators, and anyone seeking to optimize their digital productivity. Its core philosophy revolves around making technology more adaptable to user needs. By offering a flexible, customizable, and developer-friendly interface, PinDrop empowers users to overcome the inherent frustrations of inefficient typing. This leads to a more streamlined and enjoyable interaction with their devices.
If you're looking to reduce the friction in your daily digital tasks and explore the potential of voice-to-text on macOS, PinDrop is an open-source project that deserves your attention. It represents a forward-thinking approach to user interface design and productivity enhancement.
Explore the project and contribute to its development:
2026-04-24 19:20:30
The highlight of this release is an open-source email editor that outputs inbox-ready HTML. It has a composable API for building custom blocks like image uploaders or social embeds. Also new: a unified single package for all components and a fresh set of templates for auth and e-commerce flows
Vercel disclosed a security incident where an attacker compromised a third-party AI tool (Context.ai) used by an employee, gaining access to some internal systems and non-sensitive environment variables. No npm packages were affected. Vercel recommends rotating credentials, enabling 2FA, and reviewing activity logs
The new Clerk CLI detects your framework and gets auth ready to configure. Run clerk init to scaffold, clerk config to manage sign-in methods, redirects, and session policies in code, or clerk api to query users and orgs. Try it.
New docs explaining how to avoid the visible flicker when things like dates, themes, or localStorage values differ between server and client
We featured the RSC Boundary package in a previous issue. This article from its creator explains the problem it solves: When working with React Server Components, you often have to guess where the server/client split is by reading 'use client' directives and tracing imports. RSC Boundary removes that guesswork. It's a dev-only overlay that highlights which parts of your page are server-rendered and which are client components, giving you a live visual map
A thorough, hands-on migration guide covering every breaking change in Next.js 16 and how to deal with it
Next.js logs can get messy across different runtimes. This post shows how to fix that with one shared logger using LogLayer, console interception in instrumentation.ts, and structured output with Pino for production
A visual tool and React runtime for creating layered shader compositions. Render directly in your app, use them as Three.js textures, or apply built-in effects like ASCII, CRT, dithering, and pixel sorting as postprocessing over your own 3D scenes. Fully open source
A CLI tool that scans your Next.js project and shows every route as an interactive graph in your browser. It picks up pages, API routes, middleware, and HTTP methods
Handcrafted interaction animations and visual effects built with Tailwind CSS and Framer Motion. Works like shadcn/ui
The first beta release of TypeScript 7.0 is here, and it's a big deal. The compiler has been completely rewritten in Go, making it around 10x faster than TypeScript 6.0. It now supports parallel type-checking and parallel project builds out of the box. Despite being a beta, the team says it's stable enough for everyday use
Everything that web devs need to know about building their first mobile app - You already know React. With Expo, you can use that knowledge to build fully native apps for iOS and Android without starting over or learning new tools
Modern interfaces are component-first, but most responsive CSS is still viewport-first. This article bridges that gap with four methods: intrinsic layouts using auto-fit and minmax(), fluid scaling with clamp(), container units for sizing relative to a component's actual space, and container queries for true structural changes
Lessons learned from production bugs and code reviews. Includes tips like replacing multiple useState calls with useReducer, keeping state close to where it's used, using key to reset components, and choosing Compound Components over prop-heavy APIs
Explaining a different approach to WebSockets in React. Instead of putting everything in hooks, the heavy lifting lives in TypeScript classes
Breaks down exactly why LLMs produce inaccessible code and presents a practical five-layer fix: prompt constraints, static analysis with eslint-plugin-jsx-a11y, runtime testing with axe-core, CI enforcement via GitHub Actions, and using accessible component libraries like Headless UI, Radix, or React Aria
2026-04-24 19:18:08
Most threat detection tools phone home. They pull threat feeds, push telemetry, verify licenses, or at minimum require a DNS resolver to function. That assumption is baked so deep into modern NDR that nobody questions it anymore.
SNF questions it.
SNF (Shadow Network Fingerprinting) is a passive network intelligence engine written entirely in Rust. It was designed from day one for environments where outbound connectivity is not just unavailable but prohibited: air-gapped defense networks, nuclear infrastructure, industrial control systems, classified SOCs.
The architecture enforces this. There are no configuration flags to disable telemetry, no license server to bypass, no optional cloud sync to turn off. The binary makes zero network calls. Ever. If you audit the source, you will not find a single outbound socket.
SNF captures raw packets passively, reconstructs TCP/UDP flows, and runs them through 14 deterministic protocol analyzers in a fixed order:
DNS, TLS, HTTP/1.1, HTTP/2, QUIC, DHCP, ICMP, SMB, mDNS, ICS, Enterprise, Discovery, DoH, and DoT.
On top of that it fingerprints TLS sessions using JA3 and JA4, detects C2 beacon patterns by analyzing packet timing and jitter, catches DGA domains through statistical entropy analysis, identifies DNS tunnels by payload size and query frequency, and covers the full ICS/SCADA protocol suite including Modbus, S7comm, EtherNet-IP, PROFINET, and DNP3.
Everything it finds gets emitted as structured NDJSON with a deterministic guarantee: run the same PCAP with the same config on the same version and you get bit-identical output, verified by SHA-256. This matters in forensic and legal contexts where reproducibility is not optional.
Here is SNF running against a real Emotet epoch 3 + Trickbot infection PCAP. No internet connection. No threat feed pulled at runtime.
23 IOC hits. 52 threat matches. JA3 fingerprinting attributed the TLS session directly to the Emotet/Trickbot loader. The stealth detector flagged three external IPs for portscan, tunnel, and exfil activity simultaneously. A DGA candidate scored 85 on a .onion domain.
Parse errors: 0. Capture errors: 0.
Most tools produce slightly different output across runs because of timing, threading, or probabilistic components. SNF uses BTreeMap for all output so field ordering is always identical. It has a tamper-resistant monotonic session clock. It produces cryptographically signed evidence bundles that hold up in court.
Same dataset plus same config plus same version equals identical SHA-256 output. Every single time.
This is not a nice-to-have. In a DFIR investigation, in a government audit, or in a legal proceeding, output that changes between runs is inadmissible. SNF was built around this constraint from the first commit, not bolted on after.
On the MAWI backbone dataset (14.9 million packets, a real-world traffic sample used by network researchers globally), SNF processes at roughly 155,000 packets per second on a single core, sustaining around 1.25 Gbps throughput. On a 4-core VM it scales to 2.3x that with multi-worker mode.
One command. One PCAP. SNF writes structured output automatically, split by category and timestamped to the session.
Every run produces flows, devices, DNS, TLS fingerprints, IOC hits, threat matches, and a full session report in both NDJSON and CSV. No post-processing scripts. No manual export. Ready for SIEM import or court submission as-is.
The capture layer, flow reconstruction engine, and protocol parsers are open source under Apache 2.0 as snf-core on GitHub. The intelligence layer covering behavioral detection, fingerprinting, stealth mode, graph analysis, evidence bundles, SIEM export, and the threat databases is proprietary.
If you work in DFIR, ICS security, or blue team work in regulated environments, the repo is worth a look. Contributions to the open-core layer are welcome.
Website: https://shadownf.com
GitHub: https://github.com/padigeltejas/snf-core
LinkedIn: https://www.linkedin.com/company/snflabs/
2026-04-24 19:17:44
Base64 encoding is one of those small developer tasks that looks simple until you hit Unicode characters, files, APIs, or URL-safe formats.
In JavaScript, many tutorials show this:
btoa("Hello World");
And yes, it works.
But only for simple ASCII text.
Once you try to encode something like:
"Café 🚀"
you may run into errors or broken output.
In this guide, we’ll cover how Base64 encoding works in JavaScript, when btoa() is enough, when it is not, and how to encode text, Unicode, files, images, and URL-safe Base64 correctly.
You can also test examples quickly with EncodingBase64, a free browser-based Base64 encoder for text, files, images, URL-safe Base64, hex, and URL encoding.
Base64 is a way to represent binary data using readable ASCII characters.
It is commonly used when binary data needs to travel through systems that expect text, such as:
For example:
Hello World
becomes:
SGVsbG8gV29ybGQ=
Base64 does not encrypt data. Anyone can decode it.
It only changes the representation of the data.
JavaScript includes a built-in function called btoa().
Example:
const text = "Hello World";
const encoded = btoa(text);
console.log(encoded);
// SGVsbG8gV29ybGQ=
To decode it back:
const decoded = atob(encoded);
console.log(decoded);
// Hello World
This is fine for basic ASCII strings.
But there is a problem.
Try this:
const text = "Café 🚀";
const encoded = btoa(text);
console.log(encoded);
Depending on the environment, you may get an error like:
InvalidCharacterError
Why?
Because btoa() expects a binary string where each character is in the Latin-1 range. It does not directly support full Unicode text.
Modern apps often deal with:
So we need a safer method.
Use TextEncoder to convert the string into UTF-8 bytes first.
function encodeBase64Unicode(text) {
const bytes = new TextEncoder().encode(text);
let binary = "";
bytes.forEach((byte) => {
binary += String.fromCharCode(byte);
});
return btoa(binary);
}
console.log(encodeBase64Unicode("Café 🚀"));
// Q2Fmw6kg8J+agA==
Now the Unicode string is safely converted to UTF-8 before Base64 encoding.
To decode it back properly, use TextDecoder.
function decodeBase64Unicode(base64) {
const binary = atob(base64);
const bytes = Uint8Array.from(binary, (char) => {
return char.charCodeAt(0);
});
return new TextDecoder().decode(bytes);
}
const encoded = encodeBase64Unicode("Café 🚀");
const decoded = decodeBase64Unicode(encoded);
console.log(decoded);
// Café 🚀
This is safer for real-world text.
For files, you can use FileReader.
Example with an HTML file input:
<input type="file" id="fileInput" />
const input = document.getElementById("fileInput");
input.addEventListener("change", () => {
const file = input.files[0];
if (!file) return;
const reader = new FileReader();
reader.onload = () => {
console.log(reader.result);
};
reader.readAsDataURL(file);
});
The result will look like this:
data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAA...
This is called a data URI.
It includes:
data:[mime-type];base64,[base64-data]
For example:
data:image/png;base64,iVBORw0KGgo...
If you only want the raw Base64 part, remove everything before the comma:
const dataUrl = reader.result;
const rawBase64 = dataUrl.split(",")[1];
console.log(rawBase64);
Images are one of the most common Base64 use cases.
You might encode images to Base64 when:
Example HTML output:
<img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAA..." alt="Example" />
Example CSS output:
.icon {
background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAA...");
}
This is useful for small images.
But be careful: Base64 increases file size, so it is usually not ideal for large images.
For quick browser-based image conversion, EncodingBase64’s Image to Base64 tool can convert images into raw Base64, data URI, HTML, CSS, or Markdown formats.
Standard Base64 uses characters like:
+
/
=
These characters can be problematic in URLs.
URL-safe Base64 replaces:
+ with -
/ with _
Padding = may also be removed in some systems.
Example helper:
function toBase64Url(base64) {
return base64
.replace(/\+/g, "-")
.replace(/\//g, "_")
.replace(/=+$/g, "");
}
const encoded = encodeBase64Unicode("Hello World");
const urlSafe = toBase64Url(encoded);
console.log(urlSafe);
// SGVsbG8gV29ybGQ
To convert Base64URL back to standard Base64:
function fromBase64Url(base64Url) {
let base64 = base64Url
.replace(/-/g, "+")
.replace(/_/g, "/");
while (base64.length % 4 !== 0) {
base64 += "=";
}
return base64;
}
Base64URL is commonly used in:
Base64 is not secure. It is reversible.
Do not use it to protect passwords, API keys, or private data.
This can break:
btoa("Café 🚀");
Use TextEncoder instead.
Standard Base64 can contain +, /, and =. Use Base64URL when the value needs to go inside a URL.
Base64 is usually better for small assets, not large files.
For browser display, this:
iVBORw0KGgo...
may not be enough.
You often need:
data:image/png;base64,iVBORw0KGgo...
Use btoa() only for simple ASCII text.
For Unicode-safe Base64 encoding in JavaScript, convert text to UTF-8 bytes first using TextEncoder, then encode those bytes with btoa().
For files and images, use FileReader.readAsDataURL().
For URLs, convert standard Base64 into Base64URL by replacing + with -, / with _, and optionally removing = padding.
Base64 encoding is simple in theory, but real-world usage gets more complex when you deal with Unicode, files, images, URLs, and APIs.
For quick testing, debugging, and conversion, a browser-based tool like EncodingBase64 can save time because you can encode text, files, images, URL-safe Base64, hex, and URLs without setting up code.
The key rule to remember:
Base64 is an encoding format, not a security feature.
Use it when you need text-safe data representation, not when you need encryption.
2026-04-24 19:17:33
Base64 decoding looks simple.
You take a string like this:
SGVsbG8gV29ybGQ=
Decode it, and get:
Hello World
But in real projects, Base64 decoding can fail for many reasons:
This guide explains how to decode Base64 safely in JavaScript, Python, and the command line, and how to troubleshoot the most common Base64 decoding issues.
You can also test strings quickly with DecodingBase64, a free client-side Base64 decoder that converts Base64 to text, images, hex output, or downloadable files.
Base64 decoding reverses Base64 encoding.
Base64 represents bytes using readable characters. Decoding converts those characters back into the original bytes.
Those bytes may represent:
This is important:
Base64 decoding does not always produce readable text.
Sometimes the decoded output is binary data.
That is why a good decoder should support text, image, file, and hex output.
JavaScript provides atob().
const base64 = "SGVsbG8gV29ybGQ=";
const decoded = atob(base64);
console.log(decoded);
// Hello World
This works for simple ASCII text.
But it can break or produce incorrect output with Unicode text.
If the original text contained Unicode characters, you should decode bytes using TextDecoder.
function decodeBase64Unicode(base64) {
const binary = atob(base64);
const bytes = Uint8Array.from(binary, (char) => {
return char.charCodeAt(0);
});
return new TextDecoder("utf-8").decode(bytes);
}
console.log(decodeBase64Unicode("Q2Fmw6kg8J+agA=="));
// Café 🚀
This approach is safer for real-world text because it handles UTF-8 correctly.
Python has a built-in base64 module.
import base64
encoded = "SGVsbG8gV29ybGQ="
decoded_bytes = base64.b64decode(encoded)
decoded_text = decoded_bytes.decode("utf-8")
print(decoded_text)
# Hello World
For Unicode text:
import base64
encoded = "Q2Fmw6kg8J+agA=="
decoded = base64.b64decode(encoded).decode("utf-8")
print(decoded)
# Café 🚀
If the output is binary, do not decode it as text. Save it as bytes instead.
On macOS and Linux:
echo "SGVsbG8gV29ybGQ=" | base64 --decode
Output:
Hello World
To decode a Base64 file into a binary file:
base64 --decode input.txt > output.bin
For an image:
base64 --decode image-base64.txt > image.png
The correct output extension depends on the original file type.
A Base64 image often looks like this:
data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAA...
This is called a data URI.
It has two important parts:
data:image/png;base64,
and then the Base64 data:
iVBORw0KGgoAAAANSUhEUgAA...
The MIME type tells the browser what kind of file it is:
image/png
image/jpeg
image/webp
image/gif
image/svg+xml
If you only have the raw Base64 string, you may need to know the original MIME type to display or save it correctly.
For image debugging, DecodingBase64’s Base64 to Image tool can turn a Base64 image string back into a preview and downloadable image file.
Some strings are not standard Base64. They are Base64URL.
Base64URL is common in:
Standard Base64 uses:
+
/
=
Base64URL may use:
-
_
and often removes padding.
To decode Base64URL in JavaScript, normalize it first:
function base64UrlToBase64(base64Url) {
let base64 = base64Url
.replace(/-/g, "+")
.replace(/_/g, "/");
while (base64.length % 4 !== 0) {
base64 += "=";
}
return base64;
}
function decodeBase64Url(base64Url) {
const base64 = base64UrlToBase64(base64Url);
return atob(base64);
}
console.log(decodeBase64Url("SGVsbG8gV29ybGQ"));
// Hello World
If a standard decoder fails, check whether your string is actually Base64URL.
Base64 strings often end with:
=
or:
==
Padding helps make the length valid.
If padding is missing, some decoders fail.
Fix:
function addBase64Padding(base64) {
while (base64.length % 4 !== 0) {
base64 += "=";
}
return base64;
}
Standard Base64 should usually contain:
A-Z
a-z
0-9
+
/
=
If you see - and _, it may be Base64URL.
If you see spaces, quotes, commas, or copied line breaks, clean the input first.
Copied Base64 strings may contain line breaks or spaces.
const cleaned = input.replace(/\s/g, "");
Not all decoded Base64 is readable.
If the decoded bytes represent an image or file, showing them as text will look broken.
Use a file output, image preview, or hex view instead.
If the decoded text looks strange, it may be a charset issue.
Try UTF-8 first. If that fails, the original data may use another encoding.
To decode Base64 safely:
Do not assume every Base64 string is plain text.
No.
Base64 is not encryption.
Anyone can decode it.
For example:
YXBpX2tleV8xMjM=
decodes to:
api_key_123
So never use Base64 alone to protect sensitive information.
Base64 is useful for representation and transport, not security.
Base64 decoding is easy when the input is clean ASCII text.
But real-world Base64 often includes images, files, Unicode, Base64URL, missing padding, or binary data.
The safest approach is to decode carefully and inspect the output type.
For fast testing, debugging, and file/image recovery, DecodingBase64 can help because it runs client-side and supports text, image, hex, and file outputs.
Remember:
Base64 decoding gives you bytes. What those bytes mean depends on the original data.
2026-04-24 19:17:18
Base64, Base64URL, and URL encoding are often confused because they all seem to “encode” data.
But they solve different problems.
Using the wrong one can break URLs, APIs, JWTs, image data, or browser behavior.
In this guide, we’ll compare:
You’ll learn what each one does, where each one is useful, and how to choose the right format.
For quick testing, you can use EncodingBase64 for Base64, Base64URL, URL encoding, hex, and image-to-Base64 conversions. If you need to reverse Base64 back into text, images, or files, DecodingBase64 is the matching decoder.
Use Base64 when you need to represent binary data as text.
Use Base64URL when Base64 data must safely appear inside URLs, JWTs, or URL tokens.
Use URL encoding when you need to safely place normal text inside a URL query string or path.
They are not interchangeable.
Base64 converts bytes into readable ASCII characters.
Example:
Hello World
becomes:
SGVsbG8gV29ybGQ=
Base64 is commonly used for:
Base64 uses characters like:
A-Z
a-z
0-9
+
/
=
The = character is padding.
Use Base64 when the original data is binary or byte-based but needs to be represented as text.
Good use cases include:
<img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAA..." />
{
"filename": "avatar.png",
"content": "iVBORw0KGgoAAAANSUhEUgAA..."
}
Some APIs accept file content as Base64 strings.
Basic authentication uses Base64 representation for:
username:password
But remember: this is not secure by itself. It must be used over HTTPS.
Do not use Base64 for:
Base64 increases data size, often by about one-third.
That is acceptable in many cases, but not always ideal.
Base64URL is a URL-safe version of Base64.
Standard Base64 may contain:
+
/
=
These characters can cause issues in URLs.
Base64URL replaces:
+ with -
/ with _
Padding = is often removed.
Example standard Base64:
SGVsbG8+V29ybGQ/
Base64URL version:
SGVsbG8-V29ybGQ_
Base64URL is common in:
Imagine this Base64 string:
abc+def/ghi==
If placed directly inside a URL:
https://example.com/?token=abc+def/ghi==
The + may be interpreted as a space in some URL contexts.
The / may be interpreted as a path separator.
The = can interfere with query parsing.
That is why Base64URL exists.
A safer token would look like:
abc-def_ghi
Convert standard Base64 to Base64URL:
function toBase64Url(base64) {
return base64
.replace(/\+/g, "-")
.replace(/\//g, "_")
.replace(/=+$/g, "");
}
Convert Base64URL back to standard Base64:
function fromBase64Url(base64Url) {
let base64 = base64Url
.replace(/-/g, "+")
.replace(/_/g, "/");
while (base64.length % 4 !== 0) {
base64 += "=";
}
return base64;
}
Example:
const base64 = "SGVsbG8gV29ybGQ=";
const base64Url = toBase64Url(base64);
console.log(base64Url);
// SGVsbG8gV29ybGQ
URL encoding, also called percent encoding, is different from Base64.
It makes text safe for URLs by replacing unsafe characters with % followed by hexadecimal values.
Example:
hello world
becomes:
hello%20world
Another example:
becomes:
email%40example.com
In JavaScript, you can use:
encodeURIComponent("hello world");
// hello%20world
For a full URL, you may use:
encodeURI("https://example.com/search?q=hello world");
// https://example.com/search?q=hello%20world
These two are often confused.
Use it for a full URL:
encodeURI("https://example.com/search?q=hello world");
It keeps URL structure characters like:
:
/
?
&
=
Use it for a URL parameter value:
const query = encodeURIComponent("hello world & coffee");
const url = `https://example.com/search?q=${query}`;
console.log(url);
// https://example.com/search?q=hello%20world%20%26%20coffee
Most of the time, if you are encoding a query parameter value, use encodeURIComponent().
Here is the key difference:
| Feature | Base64 | URL Encoding |
|---|---|---|
| Main purpose | Represent bytes as text | Make URL text safe |
| Used for binary data | Yes | No |
| Used for query params | Not directly | Yes |
| Output style | SGVsbG8= |
hello%20world |
| Reversible | Yes | Yes |
| Security feature | No | No |
If you want to encode an image, use Base64.
If you want to safely put a search query inside a URL, use URL encoding.
Base64URL is still Base64.
It is designed to make Base64 output safe for URLs.
URL encoding is designed to make normal text safe for URLs.
Example:
Original text:
Hello World
Base64:
SGVsbG8gV29ybGQ=
Base64URL:
SGVsbG8gV29ybGQ
URL encoded:
Hello%20World
They look different because they solve different problems.
You have image bytes and need to send them in JSON.
Use Base64.
{
"image": "iVBORw0KGgoAAAANSUhEUgAA..."
}
JWTs use Base64URL.
A JWT looks like:
header.payload.signature
Each part is Base64URL encoded.
You want a URL like:
https://example.com/search?q=coffee & tea
Use URL encoding:
https://example.com/search?q=coffee%20%26%20tea
Use Base64 or URL-encoded SVG depending on the case.
For small PNG/JPEG/WebP assets, Base64 is common.
For SVG, URL encoding can sometimes be more readable and efficient.
Base64 can be decoded by anyone.
It does not protect data.
Characters like +, /, and = can cause issues.
Use Base64URL or URL encode the value.
URL encoding is not designed for raw binary file representation.
Use Base64 instead.
If data is URL encoded and Base64 encoded, the order matters.
For example:
or the reverse, depending on how the data was originally encoded.
JavaScript’s btoa() and atob() are not always Unicode-safe by themselves.
Use TextEncoder and TextDecoder when working with modern text.
Use this simple rule:
| Situation | Use |
|---|---|
| Encode text or binary as ASCII | Base64 |
| Put Base64 safely in a URL | Base64URL |
| Encode a URL query parameter | URL encoding |
| Encode an image as text | Base64 |
| Encode a JWT payload | Base64URL |
| Encode spaces and symbols in URLs | URL encoding |
| Hide sensitive data | None of these |
For sensitive data, use proper encryption, hashing, HTTPS, and secure storage depending on the use case.
Base64, Base64URL, and URL encoding are all useful, but they are not the same.
Base64 helps represent bytes as text.
Base64URL makes Base64 safer for URLs and tokens.
URL encoding makes normal URL text safe.
When debugging encoded data, first identify what kind of encoding you are dealing with. Then choose the right tool or function.
For browser-based testing, EncodingBase64 is useful for encoding workflows like Base64, Base64URL, URL encoding, image to Base64, and hex. For reverse workflows, DecodingBase64 helps decode Base64 back into text, images, hex, or files.
The main thing to remember:
Encoding is about representation. It is not the same as encryption.