Built Something Crazy This Week – Inkash

Hey dev's 👋 it's me Taqui

This week I built something that actually pushed me hard.

It’s called Inkash.

Live: https://inkash.vercel.app

GitHub: https://github.com/taqui-786/inkash (Drop a Star ⭐)

Inkash is a smart link generator that compresses real data into a short shareable URL.

• No database.


• No backend storage.


• The data lives inside the URL itself.

That was the fun part.

What Inkash Actually Does

The idea is simple:

1. Take user input
   


2. Compress it using the deflate algorithm
   


3. Convert it into a URL-safe string
   


4. Generate a shareable link
   


5. On load, decompress and restore the original content
   

So large content becomes a compact link.


When someone opens it, everything rebuilds instantly on the client.

It feels kind of crazy seeing big data turn into a short URL and still restore perfectly.

it also has markdown editor you can us

Sharing Feature:

The cool thing is,

You can generate the QR-code of the link and share it

Core Compression Logic (Simplified)

Here’s a simplified version of how compression and decompression works:

import { deflate, inflate } from "pako";



export function compressData(input: string) {

  const compressed = deflate(input);

  return btoa(

    String.fromCharCode(...compressed)

  );

}



export function decompressData(encoded: string) {

  const binary = atob(encoded);

  const bytes = Uint8Array.from(binary, (c) => c.charCodeAt(0));

  return inflate(bytes, { to: "string" });

}

Under the hood, it:

• Uses the deflate algorithm to reduce payload size
  


• Converts binary compressed data into Base64
  


• Makes the output URL safe
  


• Restores everything safely on load
  

Technical Challenges

The real challenge was not just compression.

It was making sure everything works safely inside a browser URL.

Here are some things I had to handle:

• Making compressed output URL safe
  


• Handling corrupted or invalid hashes
  


• Respecting browser URL length limits
  


• Preventing UI crashes during decompression
  


• Managing edge cases with large payloads
  


• Keeping everything fully client-side
  

If even one character in the URL changes, decompression can fail. So proper validation and error handling was very important.

Tech Stack

• Next.js
  


• TypeScript
  


• Client-side compression using pako
  


• Modern UI components
  


• Clean and scalable architecture
  

There is no database involved.

The link itself is the storage.

That was the main experiment and honestly the most fun part.

What I Learned

Building Inkash taught me:

• How the deflate algorithm works in real usage
  


• Binary to Base64 transformations
  


• URL encoding and safety concerns
  


• Browser URL length constraints
  


• How easy it is to break decoding
  


• How to build something useful without a backend
  

This project broke many times before it became stable. But once it worked, it felt clean and kind of magical.

If you check it out, I would really love honest feedback.

What would you improve or add to something like this?