India runs on language. With 22 officially recognised languages and a multitude of scripts spread across the country, the question of how to make computers “speak” these languages was never trivial. In the early days of computing, machines were built around English and the ASCII standard, leaving Hindi, Bengali, Tamil, Telugu and dozens of other scripts locked out of the digital world. The solution came in the form of a homegrown encoding standard: the Indian Standard Code for Information Interchange, better known as ISCII. This post explores how ISCII was created, the problems it ran into, and how a technology called GIST stepped in to bring Indian scripts to the screen.
Table of Contents
What is ISCII and why was it needed
To understand ISCII, you first need to understand the problem it was built to solve. Computers do not understand letters or words. They only understand binary numbers, the 0s and 1s. To display text, a computer needs a coding scheme that assigns a numeric value to every character. For English, that scheme was ASCII, a 7-bit standard that defined 128 characters covering the English alphabet, digits and punctuation.
The trouble was that ASCII had no room for Indian scripts. Typing a Hindi word like भारत was simply impossible using ASCII codes. Worse, every organisation that wanted to work with Indian languages built its own private encoding, which meant data created on one system could not be read on another. Data interchange between systems became impossible, and the whole point of standardisation was lost.
This is where ISCII entered the picture. The Indian Standard Code for Information Interchange is a character encoding standard designed specifically to represent the scripts of India. The standard was evolved by a committee under the Department of Electronics during 1986-88, and in 1991 the Bureau of Indian Standards (BIS) formally adopted it. It is documented as IS 13194:1991. The early development actually traces back further, with the first version launched in the mid-1980s and later revised in 1991 and 1997.
How ISCII works
ISCII is an 8-bit encoding, which means it can represent 256 characters in total. The design is elegant in its simplicity. The lower 128 codepoints are kept identical to standard ASCII, so English letters, digits and punctuation work exactly as before. The upper 128 characters, from positions 128 to 255, are reserved for Indian language characters. This backward compatibility with ASCII was deliberate. It meant English and Indian scripts could coexist in the same document without conflict.
The cleverest part of ISCII lies in how it handles multiple scripts with a single code table. Most Indian scripts, including Devanagari, Bengali-Assamese, Gujarati, Gurmukhi, Kannada, Malayalam, Odia, Tamil and Telugu, descend from the ancient Brahmi script. Because of this shared ancestry, these scripts have very similar phonetic structures. ISCII took advantage of this. Instead of creating a separate code table for each script, it maintained a single logical value for each character across all the Brahmi-based scripts. The same code could represent the equivalent letter in Hindi, Bengali or Tamil, depending on which script was active.
This had a remarkable benefit. Because the underlying codes were common, transliteration between different Indian scripts became possible simply by changing the display mode. A piece of text stored once could be shown in any of the supported scripts. The government also defined a common keyboard layout called INSCRIPT, designed to sit over the standard QWERTY keyboard, so that a single typing scheme worked across all Indian languages.
The challenges with ISCII
Despite its clever design, ISCII faced real limitations that eventually held it back. These problems became more obvious as computing grew more sophisticated and the demands on text systems increased.
The constraint of 8 bits
The biggest structural limitation was the 8-bit ceiling. With only 256 slots, and the first 128 already taken up by ASCII, ISCII had just 128 positions left for all Indian scripts. This worked because the Brahmi scripts share a common phonetic base, but it left little room for growth. The fixed 8-bit nature proved insufficient for more complex script combinations or characters not accounted for in the original design. Scripts not derived from Brahmi, such as the Perso-Arabic scripts used for Urdu, Sindhi and Kashmiri, could not be properly accommodated and had to be handled separately through a different standard.
Displaying multiple scripts on the same screen
A specific and tricky problem was showing more than one Indian script at the same time. Because ISCII reused the same code values across different scripts, the system needed a way to know which script a given byte was meant to represent. ISCII handled this through a mechanism called the Attribute Register, or ATR. A special codepoint signalled that the following byte indicated a change in writing system, switching the active script until the next indicator or the end of the line.
This made ISCII a stateful encoding. The meaning of a byte depended on what came before it. While this approach saved space, it created complications. The system had to constantly track which script was currently active, and a single misplaced switching code could throw off the display of everything that followed. Notably, ISCII did not provide a clear way of indicating the default writing system, which added to the ambiguity. Rendering several scripts together on one screen without errors or graphical glitches was therefore genuinely difficult.
Limited adoption
Partly because of these complexities, ISCII never achieved truly widespread use. It was used mainly within certain government institutions rather than across the wider computing industry. The standard solved a national problem at the level of code tables, but turning those codes into a working system that ordinary users could rely on required additional technology. That is exactly the gap that GIST filled.
GIST and ISCII: bringing the scripts to life
An encoding standard like ISCII is only half the story. It defines what numbers represent which characters, but it does not by itself draw those characters on a screen or print them on paper. For that, you need hardware and software that can interpret ISCII codes and render the corresponding glyphs. This is where GIST comes in.
What is GIST
GIST stands for Graphics and Intelligence based Script Technology. It was developed by the Centre for Development of Advanced Computing (C-DAC), which pioneered this technology to make Indian languages usable in information technology. The story of GIST actually runs parallel to that of ISCII itself. The initial development started in 1983 at IIT Kanpur for an Integrated Devanagari Terminal, a project sponsored by the Department of Electronics. This terminal was demonstrated in 1986 at the Vishwa Hindi Sammelan in Delhi and was seen as a technological breakthrough.
In 1988, C-DAC took the technology forward as a serious effort in socially relevant language computing. C-DAC introduced the GIST-9000 Application Specific Integrated Circuit (ASIC) to make the technology commercially viable, and in 1990 it transferred this technology to around 25 companies to manufacture GIST Cards and terminals. The common approach to Indian languages that GIST embodied is the very thing that led to the standardisation of the coding scheme as ISCII. In other words, GIST and ISCII grew together, each shaping the other.
The GIST Card
One of the most important products to emerge was the GIST Card. This was a hardware add-on card for a PC. The GIST Card allowed Indian and other scripts to be used alongside English in existing text-based applications such as dBase, FoxPro, Lotus 1-2-3 and various programming compilers running on MS-DOS. Crucially, it let users enter, process, sort, display and print data in any Indian language. It came bundled with its own multilingual word processor.
The significance of this hardware is hard to overstate. The GIST Card became the backbone of some of India’s most crucial computerisation programmes. It was used in the Land Records Programme, the Election Commission identity cards, and citizen surveys. These were massive, nationwide projects that needed to handle records in local languages, and GIST made that possible at scale.
From hardware to software
As computing moved from MS-DOS to graphical operating systems like Windows, GIST evolved too. C-DAC developed software-only solutions so that script support no longer depended on a physical card. The GIST Shell offered a software approach for character-based MS-DOS applications, while the GIST SDK enabled Windows developers to build applications that could process ISCII data directly. This shift was important because it meant Indian language support could spread to ordinary machines without specialised hardware.
GIST also tackled the very display problem that troubled ISCII. It brought the ability to process complex scripts and multi-script text efficiently and to show more than one language on the screen at the same time. This is precisely the capability that raw ISCII codes could not deliver on their own. Where ISCII provided the logic, GIST provided the practical machinery to turn that logic into readable, printable text.
The move towards Unicode
No discussion of ISCII is complete without mentioning what came after it. As the digital world became increasingly global and interconnected, the limitations of an 8-bit, India-specific standard became more pressing. The international answer was Unicode, an encoding system that aims to represent every script used in the world within a single, unified standard. Unicode supports well over a hundred thousand characters, compared with ISCII’s modest 256.
Importantly, ISCII was not discarded so much as absorbed. The committee that designed Unicode used Indian script proposals derived from the ISCII-1988 document as the basic input for the Indian portions of Unicode. As a result, Unicode encodes Indian language characters in much the same relative positions that ISCII used, preserving the structural relationships between the Brahmi scripts. The key difference is that Unicode gives each script its own dedicated block of codes, rather than sharing a single table and switching between scripts the way ISCII did. This removed the need for ISCII’s stateful script-switching mechanism altogether.
Today ISCII has been largely rendered obsolete by Unicode, which has become the universal standard for digital text. Yet its legacy is firmly embedded in the systems we use now. Every time a modern device correctly displays a word in Devanagari or Tamil, it is drawing on design ideas that ISCII pioneered decades ago. C-DAC’s GIST group, meanwhile, has continued its work, moving into natural language processing, fonts, optical character recognition and speech technology for Indian languages.
ISCII stands as an important chapter in India’s digital history. It was an early, ingenious attempt to give a multilingual nation a common digital voice, built on the insight that the country’s many scripts share a single ancient root. Combined with GIST, it allowed Indian languages to enter offices, government records and personal computers at a time when the rest of the computing world spoke only English.
What do you think? Given that ISCII used a single shared code table for many scripts while Unicode gives each script its own block, which approach do you think better reflects the linguistic reality of India? And do you believe early national standards like ISCII still deserve study today, or are they now only of historical interest?
References
- https://compile7.org/compare-character-encoding/what-is-difference-between-ascii-vs-iscii/
- https://qissba.com/encoding-schemes/
- https://www.cdac.in/index.aspx?id=mc_s_iscii
- https://www.toppr.com/guides/computer-science/computer-fundamentals/internal-storage-encoding-of-characters/iscii/
- http://tdil-dc.in/index.php?lang=en&option=com_faq
- https://www.scribd.com/document/443022956/Strings-ASCII-UTF8-UTF32-ISCII-Indian-script-code-Unicode-2-pdf
- https://www.lonweb.org/links/hindi/lang/030.htm
- https://en.wikipedia.org/wiki/Indian_Script_Code_for_Information_Interchange
- https://www.cdac.in/index.aspx?id=gistidx
- https://www.cdac.in/index.aspx?id=mlc_gist_about
- https://www.cdac.in/index.aspx?id=mlc_gist_gcard
- https://cdac.in/index.aspx?id=mlc_gist_pcigcard
- https://www.cdac.in/index.aspx?id=mlc_gist_faq
- https://cdac.in/index.aspx?id=mlc_gist_standard

Leave a Reply