Last Updated: 3/9/2026

Other Languages

Nano ID has been ported to over 20 programming languages for cross-platform ID generation.

Why Use Ports?

Consistent IDs: Generate same format across client and server
Language-specific: Native performance and idioms
No dependencies: Most ports are standalone

Available Ports

C


#include "nanoid.h"
 
char id[22];
nanoid(id, 21);
printf("%s\n", id);

C#

Repository: codeyu/nanoid-net


using Nanoid;
 
string id = Nanoid.Generate(size: 21);
Console.WriteLine(id);

C++

Repository: mcmikecreations/nanoid_cpp


#include <nanoid/nanoid.h>
 
std::string id = nanoid::generate();
std::cout << id << std::endl;

Clojure / ClojureScript

Repository: zelark/nano-id


(require '[nano-id.core :refer [nano-id]])
 
(nano-id) ;=> "V1StGXR8_Z5jdHi6B-myT"

Crystal

Repository: mamantoha/nanoid.cr


require "nanoid"
 
id = Nanoid.generate
puts id

Dart / Flutter

Repository: pd4d10/nanoid-dart


import 'package:nanoid/nanoid.dart';
 
void main() {
  final id = nanoid();
  print(id);
}

Elixir

Repository: railsmechanic/nanoid


iex> Nanoid.generate()
"V1StGXR8_Z5jdHi6B-myT"

Go

Repository: matoous/go-nanoid


import "github.com/matoous/go-nanoid/v2"
 
id, err := gonanoid.New()
fmt.Println(id)

Haskell

Repository: MichelBoucey/NanoID


import Data.NanoID
 
main = do
  id <- nanoID
  putStrLn id

Java

Repository: wosherco/jnanoid-enhanced


import com.aventrix.jnanoid.jnanoid.NanoIdUtils;
 
String id = NanoIdUtils.randomNanoId();
System.out.println(id);

Kotlin

Repository: viascom/nanoid-kotlin


import com.viascom.nanoid.NanoId
 
val id = NanoId.generate()
println(id)

Nim

Repository: icyphox/nanoid.nim


import nanoid
 
let id = generate()
echo id

OCaml

Repository: routineco/ocaml-nanoid


let id = Nanoid.gen () in
print_endline id

Perl

Repository: tkzwtks/Nanoid-perl


use Nanoid;
 
my $id = nanoid();
print "$id\n";

PHP

Repository: hidehalo/nanoid-php


use Hidehalo\Nanoid\Client;
 
$client = new Client();
$id = $client->generateId();
echo $id;

Python

Repository: puyuan/py-nanoid


from nanoid import generate
 
id = generate()
print(id)

Fast implementation (Rust): oliverlambson/fastnanoid

R

Repository: hrbrmstr/nanoid


library(nanoid)
 
id <- nano_id()
print(id)

Ruby

Repository: radeno/nanoid.rb


require 'nanoid'
 
id = Nanoid.generate
puts id

Rust

Repository: nikolay-govorov/nanoid


use nanoid::nanoid;
 
fn main() {
    let id = nanoid!();
    println!("{}", id);
}

Swift

Repository: ShivaHuang/swift-nanoid


import Nanoid
 
let id = Nanoid.new()
print(id)

Zig

Repository: SasLuca/zig-nanoid


const nanoid = @import("nanoid");
 
const id = try nanoid.generate(allocator);

Database Extensions

PostgreSQL

Repository: viascom/nanoid-postgres


CREATE EXTENSION nanoid;
 
SELECT nanoid();
-- Output: V1StGXR8_Z5jdHi6B-myT
 
CREATE TABLE users (
  id TEXT PRIMARY KEY DEFAULT nanoid(),
  email TEXT
);

MySQL / MariaDB

Repository: viascom/nanoid-mysql-mariadb


CREATE FUNCTION nanoid() RETURNS VARCHAR(21);
 
SELECT nanoid();
-- Output: V1StGXR8_Z5jdHi6B-myT

Cross-Platform Consistency

Same Algorithm

All ports use the same core algorithm:

Generate random bytes
Map to alphabet using bitmask
Return string

Same Default Settings

Alphabet: A-Za-z0-9_- (64 characters)
Size: 21 characters
Entropy: 126 bits

Example: JavaScript + Python

JavaScript:


import { nanoid } from 'nanoid'
 
const id = nanoid()
// "V1StGXR8_Z5jdHi6B-myT"

Python:


from nanoid import generate
 
id = generate()
# "V1StGXR8_Z5jdHi6B-myT"

Both generate IDs in the same format, ensuring compatibility.

Use Cases

Microservices


Node.js API → generates IDs → stores in database
Python worker → generates IDs → stores in database
Go service → generates IDs → stores in database

All use same ID format (21 chars, A-Za-z0-9_-)

Mobile + Backend


iOS (Swift) → generates IDs offline → syncs to server
Android (Kotlin) → generates IDs offline → syncs to server
Node.js backend → generates IDs → stores in database

All IDs compatible and collision-resistant

Multi-Language Stack


Frontend (JavaScript) → generates temp IDs
Backend (Go) → generates permanent IDs
Worker (Python) → generates job IDs
Database (PostgreSQL) → generates IDs via function

Consistent format across entire stack

Choosing a Port

Criteria

Maintenance: Active development and updates
Security: Uses cryptographically secure random
Performance: Optimized for target language
Compatibility: Matches JavaScript version behavior

Verification

Test a port:


1. Generate 1000 IDs
2. Check length (should be 21 by default)
3. Check alphabet (should be A-Za-z0-9_-)
4. Check uniqueness (no duplicates)
5. Check performance (>1M ops/sec for most languages)