Base64 encode anything, without uploading anything.

import base64

# Encode a string ─ note the .encode("utf-8"): b64encode takes bytes, not str
text = "Man is distinguished"
encoded = base64.b64encode(text.encode("utf-8")).decode("ascii")
print(encoded)                       # TWFuIGlzIGRpc3Rpbmd1aXNoZWQ=

# Decode it back
decoded = base64.b64decode(encoded).decode("utf-8")

# URL-safe, unpadded (RFC 4648 §5) ─ the JWT flavour
base64.urlsafe_b64encode(b"data").rstrip(b"=")

# Encode a file, wrapped at 76 characters for MIME
with open("photo.png", "rb") as f:
    mime = base64.encodebytes(f.read()).decode("ascii")

# Build a data URI for an image
uri = "data:image/png;base64," + base64.b64encode(open("photo.png", "rb").read()).decode()

// Browser, ASCII only
btoa("hello");                         // "aGVsbG8="
atob("aGVsbG8=");                      // "hello"

// Browser, Unicode-safe ─ btoa() throws above U+00FF
const bytes = new TextEncoder().encode("héllo 🎉");
const b64 = btoa(Array.from(bytes, (b) => String.fromCharCode(b)).join(""));

const text = new TextDecoder().decode(
  Uint8Array.from(atob(b64), (c) => c.charCodeAt(0))
);

// Node.js
Buffer.from("hello", "utf8").toString("base64");
Buffer.from(b64, "base64").toString("utf8");

// Modern runtimes ─ no btoa() dance needed
new TextEncoder().encode("hello").toBase64();          // "aGVsbG8="
Uint8Array.fromBase64("aGVsbG8=");

// URL-safe: swap the two characters URLs reserve, then drop padding
const urlSafe = b64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");

// Encode a file the user picked, without uploading it
const buf = new Uint8Array(await file.arrayBuffer());
const fileB64 = btoa(Array.from(buf, (b) => String.fromCharCode(b)).join(""));

# Encode a file
base64 photo.png > photo.b64

# Encode a string ─ use printf, not echo, or you encode a trailing newline too
printf %s 'hello' | base64            # aGVsbG8=
echo 'hello' | base64                 # aGVsbG8K  ← the K is the newline

# One unbroken line (GNU): disable wrapping
base64 -w 0 photo.png

# MIME-compliant 76-character lines
base64 -w 76 photo.png

# Decode
base64 -d photo.b64 > photo.png
echo 'aGVsbG8=' | base64 --decode

# URL-safe output
base64 -w 0 photo.png | tr '+/' '-_' | tr -d '='

# macOS / BSD base64 ─ no -w flag; use -i / -o, and -D to decode
base64 -i photo.png -o photo.b64
base64 -D -i photo.b64 -o photo.png

# Also available almost everywhere ─ -A keeps it on one line
openssl base64 -A -in photo.png

# Copy straight to the clipboard on macOS
base64 -i photo.png | pbcopy

# Encode a string as UTF-8
$b64 = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes('hello'))   # aGVsbG8=

# Decode it back
[Text.Encoding]::UTF8.GetString([Convert]::FromBase64String($b64))

# Encode a file
[Convert]::ToBase64String([IO.File]::ReadAllBytes("$PWD\photo.png")) | Set-Content photo.b64

# Decode a file
[IO.File]::WriteAllBytes("$PWD\photo.png", [Convert]::FromBase64String((Get-Content photo.b64 -Raw)))

# -EncodedCommand needs UTF-16 LE, not UTF-8
$cmd = [Convert]::ToBase64String([Text.Encoding]::Unicode.GetBytes('Get-Date'))
powershell -EncodedCommand $cmd

# cmd.exe: certutil ships with Windows (adds BEGIN/END header lines)
certutil -encode photo.png photo.b64
certutil -decode photo.b64 photo.png

$encoded = base64_encode('hello');        // aGVsbG8=
$decoded = base64_decode($encoded);

// Strict mode returns false instead of silently skipping invalid characters
$safe = base64_decode($input, true);
if ($safe === false) { /* not valid Base64 */ }

// URL-safe, unpadded
$url = rtrim(strtr(base64_encode($raw), '+/', '-_'), '=');

// A file as a data URI
$uri = 'data:image/png;base64,' . base64_encode(file_get_contents('photo.png'));

// MIME, 76-character lines
$mime = chunk_split(base64_encode($raw), 76, "\r\n");

import java.util.Base64;
import java.nio.charset.StandardCharsets;
import java.nio.file.*;

// Always name the charset explicitly ─ the platform default is a portability bug
String encoded = Base64.getEncoder()
    .encodeToString("hello".getBytes(StandardCharsets.UTF_8));

byte[] raw  = Base64.getDecoder().decode(encoded);
String text = new String(raw, StandardCharsets.UTF_8);

// URL-safe, unpadded (RFC 4648 §5)
String jwtPart = Base64.getUrlEncoder().withoutPadding().encodeToString(bytes);

// MIME ─ 76-character lines separated by CRLF
String mime = Base64.getMimeEncoder()
    .encodeToString(Files.readAllBytes(Path.of("photo.png")));

import (
    "encoding/base64"
    "io"
    "os"
)

encoded := base64.StdEncoding.EncodeToString([]byte("hello"))  // aGVsbG8=

decoded, err := base64.StdEncoding.DecodeString(encoded)
if err != nil { /* not valid Base64 */ }

// URL-safe and unpadded ─ what JWT libraries use
token := base64.RawURLEncoding.EncodeToString(raw)

// A file
data, _ := os.ReadFile("photo.png")
uri := "data:image/png;base64," + base64.StdEncoding.EncodeToString(data)

// Stream a large file instead of holding it all in memory
f, _ := os.Open("video.mp4")
defer f.Close()
w := base64.NewEncoder(base64.StdEncoding, os.Stdout)
io.Copy(w, f)
w.Close()   // Close() flushes the final partial group ─ don't skip it

using System;
using System.IO;
using System.Text;

string encoded = Convert.ToBase64String(Encoding.UTF8.GetBytes("hello"));
string text    = Encoding.UTF8.GetString(Convert.FromBase64String(encoded));

// MIME ─ inserts CRLF every 76 characters
Convert.ToBase64String(bytes, Base64FormattingOptions.InsertLineBreaks);

// URL-safe (.NET 9+)
System.Buffers.Text.Base64Url.EncodeToString(bytes);

// A file as a data URI
string uri = "data:image/png;base64," +
    Convert.ToBase64String(File.ReadAllBytes("photo.png"));

// Validate untrusted input without throwing
if (Convert.TryFromBase64String(input, buffer, out int written)) { /* ok */ }

require 'base64'

encoded = Base64.strict_encode64('hello')   # "aGVsbG8="
decoded = Base64.decode64(encoded)

# encode64 wraps at 60 chars and adds a trailing newline ─ rarely what you want
Base64.encode64('hello')                    # "aGVsbG8=\n"

# URL-safe (RFC 4648 §5)
Base64.urlsafe_encode64(raw, padding: false)

# A file ─ binread avoids any encoding conversion
Base64.strict_encode64(File.binread('photo.png'))