unicode on S Anand

Using SVG favicons with Unicode

Thu, 01 Jan 2026 13:00:00 +0000

Browsers support SVG favicons as data: URLs.

For example, this SVG:

<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32">
  <circle cx="16" cy="16" r="15" fill="#2563eb"/>
  <path fill="#fff" d="m16 7 2 7 7 2-7 2-2 7-2-7-7-2 7-2Z"/>
</svg>

… can be:

Compressed via svgomg
Converted to a data: URL via svgviewer
Inserted into HTML like this:

<link rel="icon" type="image/svg+xml" href="data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20viewBox%3D%220%200%2032%2032%22%3E%3Ccircle%20cx%3D%2216%22%20cy%3D%2216%22%20r%3D%2215%22%20fill%3D%22%232563eb%22%2F%3E%3Cpath%20fill%3D%22%23fff%22%20d%3D%22m16%207%202%207%207%202-7%202-2%207-2-7-7-2%207-2Z%22%2F%3E%3C%2Fsvg%3E"/>

The fun part is that you can use text inside the SVG, styled as you wish:

<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64">
  <rect fill="#2563eb" width="64" height="64" rx="10"/>
  <text x="32" y="35" text-anchor="middle" dominant-baseline="middle" font-size="40" font-weight="800" fill="white">DS</text>
</svg>

… or even use Unicode characters:

<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64">
  <rect fill="#2563eb" width="64" height="64" rx="10"/>
  <text x="32" y="35" text-anchor="middle" dominant-baseline="middle" font-size="40">🌈</text>
</svg>

That can be converted into a HTML link like this:

<link rel="icon" type="image/svg+xml" href="data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20viewBox%3D%220%200%2064%2064%22%3E%3Crect%20width%3D%2264%22%20height%3D%2264%22%20fill%3D%22%232563eb%22%20rx%3D%2210%22%2F%3E%3Ctext%20x%3D%2232%22%20y%3D%2235%22%20dominant-baseline%3D%22middle%22%20font-size%3D%2240%22%20text-anchor%3D%22middle%22%3E%F0%9F%8C%88%3C%2Ftext%3E%3C%2Fsvg%3E"/>

The variety is endless!

What makes this powerful is that:

You can create entire families of favicons using typography, Unicode characters, and colors.
The favicons are tiny (a few hundred bytes).
They’re easy to edit and maintain (just edit the SVG text).

Mapscii Rendering

Wed, 26 Nov 2025 00:00:00 +0530

I asked Claude Sonnet 4.5 on GitHub Copilot:

How does mapscii render vector tiles as text blocks on the terminal? What are the libraries it uses and how does it use them? Explain as a detailed tutorial with examples so that I can learn how to rasterize vector shapes on the terminal.

Below’s the explanation. What’s noteworthy to me is:

How it uses Braille characters to get 8 pixels per character cell (2x4 grid).
How it fills polygons using (a) triangulation and (b) getting all edge points using Bresenham’s algorithm, then (c) filling horizontal spans between edge pairs.

I’ll help you understand how mapscii renders vector tiles as text blocks on the terminal. Let me search through the repository to find the relevant code and understand the architecture. Now let me get more specific files to understand the rendering pipeline better:# How MapSCII Renders Vector Tiles as Text Blocks on the Terminal

MapSCII is a fascinating project that transforms geographic vector tiles into ASCII/Braille art on your terminal. Let me break down the complete rendering pipeline with detailed examples so you can learn how to rasterize vector shapes on the terminal.

Architecture Overview

The rendering pipeline consists of several key components:

TileSource - Fetches and manages vector tiles
Tile - Parses vector tile data (Protobuf format)
Renderer - Orchestrates the rendering process
Canvas - Provides drawing primitives (lines, polygons)
BrailleBuffer - Converts pixels to Braille/ASCII characters

Key Libraries Used

{
  "@mapbox/vector-tile": "^1.3.1", // Parse vector tile format
  "pbf": "^3.2.1", // Protobuf decoding
  "earcut": "^2.2.2", // Polygon triangulation
  "rbush": "^3.0.1", // 2D spatial indexing
  "bresenham": "0.0.4", // Line rasterization
  "simplify-js": "^1.2.4", // Polyline simplification
  "x256": "0.0.2" // Color conversion to xterm-256
}

Step-by-Step Tutorial

Step 1: Understanding Braille Characters for Pixels

Braille characters are perfect for terminal graphics because each character represents a 2×4 pixel grid:

// BrailleBuffer uses Unicode Braille patterns (U+2800 - U+28FF)
// Each Braille character has 8 dots in a 2×4 grid:
//
// ⠁ ⠂  (left column: 0x1, 0x2, 0x4, 0x40)
// ⠄ ⠈  (right column: 0x8, 0x10, 0x20, 0x80)
// ⠐ ⠠
// ⠈ ⡀

const brailleMap = [
  [0x1, 0x8],
  [0x2, 0x10],
  [0x4, 0x20],
  [0x40, 0x80],
];

Each Braille character gives you 8 pixels in just one terminal cell, effectively quadrupling your resolution!

Step 2: Creating a Braille Buffer

class BrailleBuffer {
  constructor(width, height) {
    // Map of which bits correspond to which dot positions
    this.brailleMap = [
      [0x1, 0x8],
      [0x2, 0x10],
      [0x4, 0x20],
      [0x40, 0x80],
    ];

    // Store pixel state, colors
    const size = (width * height) / 8; // Each cell stores 8 pixels
    this.pixelBuffer = Buffer.alloc(size);
    this.foregroundBuffer = Buffer.alloc(size);
    this.backgroundBuffer = Buffer.alloc(size);
  }

  // Set a single pixel at (x, y)
  setPixel(x, y, color) {
    if (x >= 0 && x < this.width && y >= 0 && y < this.height) {
      // Project x,y to buffer index
      const idx = (x >> 1) + (this.width >> 1) * (y >> 2);

      // Get the specific dot mask for this pixel
      const mask = this.brailleMap[y & 3][x & 1];

      // Set the bit
      this.pixelBuffer[idx] |= mask;
      this.foregroundBuffer[idx] = color;
    }
  }

  // Generate terminal output
  frame() {
    const output = [];
    let currentColor = null;

    for (let y = 0; y < this.height / 4; y++) {
      for (let x = 0; x < this.width / 2; x++) {
        const idx = (y * this.width) / 2 + x;

        // Add ANSI color codes when color changes
        const colorCode = this._termColor(
          this.foregroundBuffer[idx],
          this.backgroundBuffer[idx],
        );
        if (currentColor !== colorCode) {
          output.push(currentColor = colorCode);
        }

        // Convert pixel bits to Braille character
        const brailleChar = String.fromCharCode(0x2800 + this.pixelBuffer[idx]);
        output.push(brailleChar);
      }
      output.push("\n");
    }

    return output.join("");
  }

  _termColor(foreground, background) {
    if (foreground && background) {
      return `\x1B[38;5;${foreground};48;5;${background}m`;
    } else if (foreground) {
      return `\x1B[49;38;5;${foreground}m`;
    }
    return "\x1B[39;49m"; // Reset
  }
}

Step 3: Drawing Lines with Bresenham’s Algorithm

const bresenham = require("bresenham");

class Canvas {
  constructor(width, height) {
    this.buffer = new BrailleBuffer(width, height);
  }

  // Draw a line from point A to point B
  line(from, to, color, width = 1) {
    if (width === 1) {
      // Simple bresenham for single-pixel width
      bresenham(from.x, from.y, to.x, to.y, (x, y) => {
        this.buffer.setPixel(x, y, color);
      });
    } else {
      // Thick line using Bresenham with width
      this._thickLine(from.x, from.y, to.x, to.y, width, color);
    }
  }

  // Draw a polyline (e.g., roads, rivers)
  polyline(points, color, width = 1) {
    for (let i = 1; i < points.length; i++) {
      this.line(points[i - 1], points[i], color, width);
    }
  }
}

Step 4: Drawing Filled Polygons with Earcut

For filled areas (buildings, water bodies), MapSCII uses polygon triangulation:

const earcut = require("earcut");

class Canvas {
  polygon(rings, color) {
    // Convert rings to flat array of vertices
    const vertices = [];
    const holes = [];

    for (const ring of rings) {
      if (vertices.length) {
        holes.push(vertices.length / 2); // Mark hole start
      }
      for (const point of ring) {
        vertices.push(point.x);
        vertices.push(point.y);
      }
    }

    // Triangulate the polygon
    const triangles = earcut(vertices, holes);

    // Draw each triangle
    for (let i = 0; i < triangles.length; i += 3) {
      const pa = [vertices[triangles[i] * 2], vertices[triangles[i] * 2 + 1]];
      const pb = [
        vertices[triangles[i + 1] * 2],
        vertices[triangles[i + 1] * 2 + 1],
      ];
      const pc = [
        vertices[triangles[i + 2] * 2],
        vertices[triangles[i + 2] * 2 + 1],
      ];

      this._filledTriangle(pa, pb, pc, color);
    }
  }

  _filledTriangle(pointA, pointB, pointC, color) {
    // Get edges using Bresenham
    const a = bresenham(pointB[0], pointB[1], pointC[0], pointC[1]);
    const b = bresenham(pointA[0], pointA[1], pointC[0], pointC[1]);
    const c = bresenham(pointA[0], pointA[1], pointB[0], pointB[1]);

    // Combine and sort all edge points by Y, then X
    const points = a
      .concat(b)
      .concat(c)
      .filter((p) => p.y >= 0 && p.y < this.height)
      .sort((a, b) => (a.y === b.y ? a.x - b.x : a.y - b.y));

    // Fill horizontal spans between edge pairs
    for (let i = 0; i < points.length - 1; i++) {
      const point = points[i];
      const next = points[i + 1];

      if (point.y === next.y) {
        // Draw horizontal line
        for (let x = point.x; x <= next.x; x++) {
          this.buffer.setPixel(x, point.y, color);
        }
      } else {
        this.buffer.setPixel(point.x, point.y, color);
      }
    }
  }
}

Step 5: Processing Vector Tiles

const VectorTile = require("@mapbox/vector-tile").VectorTile;
const Protobuf = require("pbf");
const RBush = require("rbush");
const zlib = require("zlib");

class Tile {
  async load(buffer) {
    // Decompress if gzipped
    if (this._isGzipped(buffer)) {
      buffer = await new Promise((resolve, reject) => {
        zlib.gunzip(buffer, (err, data) => {
          err ? reject(err) : resolve(data);
        });
      });
    }

    // Parse Protobuf
    this.tile = new VectorTile(new Protobuf(buffer));

    // Process each layer
    const layers = {};
    for (const name in this.tile.layers) {
      const layer = this.tile.layers[name];
      const nodes = [];

      for (let i = 0; i < layer.length; i++) {
        const feature = layer.feature(i);
        const geometries = feature.loadGeometry();

        // Get style for this feature
        const style = this.styler.getStyleFor(name, feature);
        if (!style) continue;

        // Convert geometries to nodes with boundaries
        for (const points of geometries) {
          nodes.push(
            this._addBoundaries({
              layer: name,
              style,
              points,
              color: this._getColor(style),
            }),
          );
        }
      }

      // Create spatial index for efficient querying
      const tree = new RBush(18);
      tree.load(nodes);

      layers[name] = {
        extent: layer.extent,
        tree,
      };
    }

    return layers;
  }
}

Step 6: The Complete Rendering Pipeline

class Renderer {
  async draw(center, zoom) {
    this.canvas.clear();

    // 1. Calculate visible tiles
    const tiles = this._visibleTiles(center, zoom);

    // 2.  Fetch all tiles in parallel
    await Promise.all(
      tiles.map(async (tile) => {
        tile.data = await this.tileSource.getTile(
          tile.xyz.z,
          tile.xyz.x,
          tile.xyz.y,
        );

        // 3. Query spatial index for visible features
        const scale = tile.data.layers[layerId].extent / tileSize;
        tile.layers[layerId].features = tile.data.layers[layerId].tree.search({
          minX: -tile.position.x * scale,
          minY: -tile.position.y * scale,
          maxX: (this.width - tile.position.x) * scale,
          maxY: (this.height - tile.position.y) * scale,
        });
      }),
    );

    // 4. Draw features in correct order (background to foreground)
    const drawOrder = ["water", "landuse", "building", "road", "poi_label"];
    for (const layerId of drawOrder) {
      for (const tile of tiles) {
        for (const feature of tile.layers[layerId].features) {
          this._drawFeature(tile, feature, scale);
        }
      }
    }

    // 5. Generate terminal output
    return this.canvas.frame();
  }

  _drawFeature(tile, feature, scale) {
    // Transform coordinates from tile space to screen space
    const points = feature.points.map((p) => ({
      x: Math.floor(tile.position.x + p.x / scale),
      y: Math.floor(tile.position.y + p.y / scale),
    }));

    // Draw based on geometry type
    switch (feature.style.type) {
      case "line":
        this.canvas.polyline(
          points,
          feature.color,
          feature.style.paint["line-width"],
        );
        break;
      case "fill":
        this.canvas.polygon([points], feature.color);
        break;
      case "symbol":
        this.canvas.text(
          feature.label,
          points[0].x,
          points[0].y,
          feature.color,
        );
        break;
    }
  }
}

Step 7: Coordinate Transformations

const utils = {
  // Convert lat/lon to tile coordinates at zoom level
  ll2tile(lon, lat, zoom) {
    const n = Math.pow(2, zoom);
    return {
      x: ((lon + 180) / 360) * n,
      y: ((1
        - Math.log(
            Math.tan((lat * Math.PI) / 180)
              + 1 / Math.cos((lat * Math.PI) / 180),
          ) / Math.PI) / 2) * n,
    };
  },

  // Convert tile coordinates back to lat/lon
  tile2ll(x, y, zoom) {
    const n = Math.pow(2, zoom);
    return {
      lon: (x / n) * 360 - 180,
      lat: (Math.atan(Math.sinh(Math.PI * (1 - (2 * y) / n))) * 180) / Math.PI,
    };
  },

  // Get tile size in pixels at fractional zoom
  tilesizeAtZoom(zoom) {
    return Math.pow(2, zoom - Math.floor(zoom)) * 256;
  },
};

Complete Example: Drawing a Simple Map

const Canvas = require("./Canvas");
const x256 = require("x256");

// Create a 160x64 pixel canvas (80x16 terminal cells in Braille mode)
const canvas = new Canvas(160, 64);

// Define some colors (xterm-256 color codes)
const BLUE = x256([0, 0, 255]);
const GREEN = x256([0, 200, 0]);
const GRAY = x256([128, 128, 128]);

// Draw a river (polyline)
const riverPoints = [
  { x: 20, y: 50 },
  { x: 40, y: 45 },
  { x: 60, y: 40 },
  { x: 80, y: 35 },
  { x: 100, y: 30 },
];
canvas.polyline(riverPoints, BLUE, 3);

// Draw a building (polygon)
const buildingRing = [
  { x: 70, y: 20 },
  { x: 90, y: 20 },
  { x: 90, y: 40 },
  { x: 70, y: 40 },
];
canvas.polygon([buildingRing], GRAY);

// Draw a road (polyline)
const roadPoints = [
  { x: 0, y: 25 },
  { x: 160, y: 25 },
];
canvas.polyline(roadPoints, GRAY, 2);

// Draw a label
canvas.text("Town Hall", 80, 30, GRAY);

// Output to terminal
process.stdout.write(canvas.frame());

Performance Optimizations

MapSCII uses several clever optimizations:

RBush Spatial Index: Only processes features visible in the viewport
Polyline Simplification: Uses simplify-js to reduce point counts
Tile Padding: Renders slightly beyond viewport to avoid edge artifacts
Draw Order Optimization: Different layer orders for different zoom levels
Color Caching: Avoids repeated color conversions

Key Takeaways

To rasterize vector shapes on the terminal:

Use Braille characters for 4x resolution boost (2×4 pixels per cell)
Implement a pixel buffer that maps coordinates to Braille dot positions
Use Bresenham’s algorithm for line rasterization
Use Earcut for polygon triangulation and scanline filling
Leverage xterm-256 colors with ANSI escape codes
Transform coordinates from geographic space to screen space
Use spatial indexing (RBush) for efficient viewport queries

The complete rendering pipeline is: Vector Tiles → Parse Protobuf → Query Spatial Index → Transform Coordinates → Rasterize to Pixels → Convert to Braille → Output ANSI Codes

You can explore more implementation details in the rastapasta/mapscii repository.

Things I Learned - 08 Dec 2024

Sun, 08 Dec 2024 00:00:00 +0000

This week, I learned:

ChatGPT uses several unusual unicode characters for citations. Ref
NumLock can be dangerous. An IT support team member took control of Radheya’s screen while debugging and had turned on NumLock. Radheya’s login failed after that. After 5 tries, he was locked out.
With LLMs, most architectural decisions are no longer one-way doors. Steve Yegge
The cost of intelligence is trending to zero. How do we plan for this? Logan Kilpatrick
- If you are not planning for the price of intelligence to go to zero, the next 3-5 years are going to incredibly disruptive to your business / life.
- The important but not stated caveat: consumer willingness to pay for AI is going to go up (a lot). It will be fascinating to watch consumer willingness, cost, and the amount of AI being used all move in different directions.
- Everyone building things with AI has an economic incentive to limit the amount of AI because of cost, which inherent limits the value prop. This will change as intelligence goes up and cost goes down.
- What this means is:
  - Admin automation: Administrative tasks vanish into background AI. Booking meetings, managing finances, or even planning family activities will require less thought.
  - Hyper-personalization: Individuals get tailor-made everything—from medical advice to product recommendations to daily schedules. Systems learn your quirks.
  - AI co-brains: AI co-worker “assistants support you at any moment. Productivity soars in knowledge work. “I’ll have my AI follow up becomes a normal response.
  - Humanity valued more: As AI handles rote tasks, humans move up the value chain, focusing on creativity, empathy, or the “last-mile decisions.
  - New business models:
    - AI experts as a service
    - Embedded AI Solutions
    - AI micro-services for smart-calls
    - Distributed AI
Arena Hard is a set of hard prompts to test LLMs. Here is the code and evaluation
LLMs can detect clear outliers easily. PROMPT: Which is the outlier in this dataset: (1,7), (2,7), (3,6), (4,6), (5,5), (6,1), (7,5), (8,3), (9,1), (10,1) (ANS: (6,1))
- 🟢 GPT-4o on ChatGPT gets this. GPT-4o Mini on the API gets it too.
- 🟢 Gemini Pro, Flash, Flash 8b gets this right straight away, without even thinking.
- 🟢 Claude 3.5 Sonnet, Claude 3 Haiku, Claude 3.5 Haiku get it on LLM Foundry. 🔴 Claude.ai, where it visualizes it and gets it wrong.
- 🟢 Nova Micro, Lite, and Pro get it right.
- 🟢 Llama 3.1 70b gets it right. 🔴 Llama 3.2 8b gets it wrong. Llama 3.2 70b, Llama 3.1 8b enter repetition.
To install Docker on Windows without admin privileges, use net localgroup docker-users "your-user-id" /ADD
A non-administrator in a Google Groups domain can only add 200 emails to a group from the UI directly without invitation at a time. The only programmatic way to add users is for an administrator to add them. Even apps that use the Google Admin SDK need an admin to log in to access the relevant API.
Take 100% of your work, including complex, multi step processes and put it into an LLM. It might fail at some but you will discover the limitations.
I emailed Straive employees about their use of LLM Foundry - the internal LLM portal. I picked ~500 non-users from teams that otherwise have high (30%+) usage.
- Reasons they didn’t use it were:
  - 40% had not heard of it.
  - 40% were unclear of the benefits
  - 20% didn’t have time
- 45% feel they don’t have enough information and training to use it
- Some feedback
  - Sharing training videos will help
  - Live training sessions that allows for Q&A will help
  - Developers prefer detailed documentation
  - The same prompt gives different results
- Possible solution: Email non-users introducing the tool and sharing a quick 15-minute tutorial and a 1-page quick start.
My notes on the Amazon Nova models. More on Hacker News
- Nova Micro (3.75c/MTok) has the same cost as Gemini 1.5 Flash 8b but does not support images or documents.
- Nova Lite (6c/MTok) has about the same cost as Gemini 1.5 Flash 002 and supports images and documents (but not audio or video). It may be a good alternative. But GPT-4o mini, which is 2.5X costlier, is much better. (It partly passes the Gr brx vshdn Fdhvdu flskhu? test which Nova Lite fails.)
- Nova Pro (80c/MTok) is cheaper than Gemini 1.5 Pro and a lot cheaper than GPT 4o, but does not match their quality.
LLMs are great at convincing you of wrong things. A danger and something to be wary of. Ethan Mollick
Fish eye text summary is a great way to read text while summarizing context. Amelia Wattenberger
DuckDB’s JavaScript API is still under development. For example, JSON, ARRAY are not insertable. Plus, re-creating persistent HNSW indices crashes.
What’s a good text splitter library to use in JS?
- LangChain: If you use it, use it with a simple wrapper decoupled from the implementation (e.g. your own parameters) that you can replace later.
  - Popular
  - Fit-for-purpose. MarkdownTextSplitter which inherits from RecursiveCharacterTextSplitter is what’s needed in most cases.
  - Unstable
  - Poorly maintained Python docs indicate version 0.0 but it is in 0.1
  - Under-maintained Last update was 3 months ago, 13 Sep 2024
- LlamaIndex:
  - Popular
  - Not an ideal fit. MarkdownNodeParser does not support chunk size. SentenceWindowNodeParser does not capture Markdown headings.

Things I Learned - 19 May 2024

Sun, 19 May 2024 00:00:00 +0000

This week, I learned:

In Scandinavia, Århus comes after Zürich because Å is a different letter. It was added by the Dutch after WW2 to distance themselves from the Germans. via
Zalgo text is where we combine multiple Unicode combining characters
Artificial Analysis benchmarks LLM APIs on speed, cost, and quality.

Notepad easter egg is really a bug

Thu, 23 Nov 2006 12:00:00 +0000

If you create a file in Windows Notepad with the string “bush hid the facts”, save it and reopen it, it shows you boxes. Same with “this app can break”. Here’s why. It has nothing to do with George Bush or Microsoft. It’s just that these strings are in ASCII, but they also constitute valid Unicode strings, and Notepad guesses (wrongly) that they are in fact Chinese Unicode files.

Making a Tamil transliterator

Mon, 28 Aug 2006 12:00:00 +0000

I've built a simple Tamil transliterator. You can type in words in English and it will spell them out in Tamil. You can copy-paste the Tamil above into Microsoft Word, etc.

You may need to turn on tamil scripts to see the Tamil fonts above. If you have Windows 98, it may not work well. If you've visited this page recently, you will need to refresh this page as well (press F5).

Browse through my Javascript to see how it works. Feel free to reuse.

I've also made a Google Gadget that searches Google in Tamil using this tool.

Here's what to type:

Tamil	English
அ	a
ஆ	A or aa
இ	i
ஈ	I or ee
உ	u
ஊ	U or oo
எ	e
ஏ	E
ஐ	ai
ஒ	o
ஓ	O
ஔ	au
க	k or g
ங	n
ச	ch or s
ஜ	j
ஞ	n
ட	t or d
ண	N
த	th or dh
ந	n
ப	p or b
ம	m
ய	y
ர	r
ல	l
வ	v
ழ	zh
ள	L
ற	R
ஷ	sh
ஸ	S
ஹ	h

I also have a gadget that lets you search in Tamil.

Comments

Arun 31 Aug 2006 8:29 am: Very cool. Why the UI change?
S Anand 31 Aug 2006 10:55 am: Mostly because I wanted to shift focus from “linking” to “writing”.
Sathya 31 Aug 2006 11:06 am: wow … the commenting is back ! great ! In my spare time I would test this and if possible enhance the transtamil. Currently “Aiyya” does not get transliterated and so on.
S Anand 31 Aug 2006 4:19 pm: Try ‘aiyya’ with the small ‘a’. That works. I am allowing only lowercase except for long vowels.
Arun 1 Sep 2006 6:23 am: Ah, ok. Just a suggestion. Maybe you could use up more of the screen width? Lot of screen real-estate is not used currently (at least, on Firefox), so there’s a lot of scrolling (down) to do.
S Anand 1 Sep 2006 7:13 am: Arun, I thought a lot about this. While this makes it tougher on people who visit my site a lot, most newcomers find a linear flow easier. Since 90% of the traffic to my site is newcomers (most regular readers use RSS), I thought it best to design it this way. Just curious – what do you scroll down for? The links?
Arun 1 Sep 2006 11:55 am: I scrowl down for the links, yes. Actually, I don’t check all of them out when I first see your updates. Usually, return 2-3 times a day, when I am more in the mood to read. I sometimes tend to return to your old posts 4-5 days later. Also, I was a bit confused about the separation between the links and your writings. I didn’t realize that till you explained in your previous comment. Actually, I see your updates on google reader, but for whatever reason, I check your page too. Don’t know why I do that! :-)
sathish 21 Sep 2006 3:59 am: very nice anand. Thank you.
Vidya 6 Oct 2006 5:42 am: how can i get sri?
Vidya 6 Oct 2006 5:45 am: got it.. Dont bother to reply
RMurali 20 Nov 2006 7:06 pm: Dear Anand, I got to know your site while searching London on youtube videos. you are doing a good job. keep it up !
Victor 17 Jan 2007 10:21 pm: try aeiou as a word. remains as aeiou. Seems to be a method to the madness since these are all vowels
venkatachalam 18 Jan 2007 4:46 pm: thsi is very nice.can you please tell me which free software help me to do this transliteration.pl mail to bvchalam1946@gmail.com
Siva Prasadh 12 Apr 2007 3:28 pm: Its very useful i like it very much
senthil 28 Aug 2006 12:00 pm: its good buddy.. very easy…
sridhar 28 Aug 2006 12:00 pm: Superappu…..!
sriram 28 Aug 2006 12:00 pm: how do you write the character ‘akk’? (Aaytha ezhuthu), as in ‘fa’ inn faathima?
meenakshi 28 Aug 2006 12:00 pm: great tool!! checked it and worked very well, only issue i had was i could not figure out how to get the nya working, as in kavinyar.
Kavitha 28 Aug 2006 12:00 pm: Ur site is simply excellent. Very very useful for Tamilians….Tamil Patru Ullavanga across the world.
ராஜ் தொழில்நுட்பம்.com 28 Aug 2006 12:00 pm: வணக்கம் ஐயா,
தமிழ் எண்கள் க, உ ஆகியவை செயல்படுத்தச்செய்தால் மிக நன்று. இருந்தாலும் மிக அருமை.
இங்ஙனம், ராஜ்
thozhilnutpam.com; geocities.com/tamildictionary
RAAJARAM K 28 Aug 2006 12:00 pm: மிக அருமை. இண்டெர்னெட் ல் இல்லாத போது உபயோகிப்பது எவ்வாறு என்று தெரிவித்தால் நன்றாக இருக்கும்.