About Igor Dimitrijević

The Spark

Igor was born in 1993, in Serbia. From a very young age, he was a curious boy who loved discovering new things, with a gift for logic and linguistics. Notably, without going through the usual process of sounding out words letter by letter, he began reading fluently in Serbian in both Latin and Cyrillic scripts at the age of 5.5. He was always fascinated by technology, analyzing and trying to reverse-engineer cellphones and gaming consoles from a very young age. Having no family background in IT, he was left to his own devices, which only further sparked his self directed curiosity.

The Linguistic Interface

Before writing code, Igor was decoding human languages. Through exposure to video games and TV shows (mostly crime procedurals), he taught himself English, followed by conversational proficiency in Spanish through self study, and excelled academically in French. Growing up speaking Serbian gave him natural comprehension of related South Slavic languages. This period established his ability to recognize patterns and syntax, skills he would soon transfer to machines. Simultaneously, his creative side was also nurtured when his music professor invited him to join the school choir and later to perform as a soloist.

The First Authored Byte

At the age of 13, he began learning to code, starting with HTML, CSS, and JavaScript on a 1.5 inch screen ( Sony Ericsson J300i) because he did not own a computer. He spent ~8 hours a day reading and experimenting. Often, after playing outside with friends, he would pull out the phone and start building HTML pages on Peperonity while they gathered around, curious and amused, watching each line take shape. He created several Peperonity sites, marking his first transition from consumer to creator.

The Psycho Logic Gap

In gymnasium, Igor was an exemplary student in IT and languages, earning repeated commendations from professors. He developed a strong fascination with Latin for its rigid structure and Psychology for its insight into human logic. Seeking that same clarity in other subjects, he began translating abstract mathematical concepts into programming logic. He demystified the ∑ (summation) and ∏ (product) operators by re imagining them as for loops, and neutralized the complexity of Absolute Value (|x|) by recognizing it as simple branching logic. He extended this lens to Propositional Logic, instantly recognizing Tautologies as the mathematical equivalent of Boolean logic and mapping Logical Quantifiers the Universal (∀) and Existential ( ∃) to loop integrity and early exit patterns. By treating mathematical "sentence structures" as execution paths, he turned the curriculum into a series of predictable algorithms.

The Early Domain Convergence

Before fully committing to software development as a career, Igor's interests moved between veterinary medicine, human medicine, psychology, and linguistics, all driven by the same urge to decode rule based systems. Coding had already been a deep passion since early adolescence and something he always knew he would pursue seriously. These other fields helped crystallize the decision. He soon saw that programming could completely absorb and unify them all, demanding linguistic precision for both code and communication, modeling biological and psychological mechanisms, and offering unmatched leverage to build, debug, and optimize across any domain.

Global Ping: Mobile Signal

After mastering Web development basics, he built a site on XTgem (skywap.xtgem.com) which won an award in a global Best Website contest. Following this, he taught himself PHP and WordPress. During high school, he excelled in Pascal and Delphi (Object Pascal), despite still not owning a computer to practice at home.

The First Convergent Innovation

Noticing the need for a standardized JavaScript library, Igor created Nyx (named after Nyx, the Greek goddess of night). He built methods like $(), .first(), and .ready() from scratch, only later discovering that jQuery had independently implemented identical patterns. This was Igor's first lesson in convergent problem solving and original abstraction design. He used it extensively in his later projects. Without a modern setup, Igor's curiosity and persistence became his most powerful tools.

The Mobile Laboratory

While studying determinants, Igor developed a solver application on his HTC HD2 using a combination of HTML, CSS, and JavaScript. The utility allowed him to complete a comprehensive mathematics examination in 15 minutes, significantly outperforming the allocated time, astonishing his professor by finishing the exam in record time. During this period, the mobile device served as a primary engineering environment. He mastered its hardware architecture, utilized Basic4PPC to target the Windows Mobile environment, and performed low level system modifications, including rooting and flashing over 10 custom Android ROMs.

A Symbolic Departure

Just before graduation, his IT professor presented him with a symbolic gift. It was a children's book inscribed with gratitude for his ingenuity, calling it a privilege to have had him as a student.

A record of this event can be found in his high school memories page.

The Earned Machine

Immediately after high school, Igor built his next project, a WordPress based site, which generated his first earnings. By the age of 19, he had saved enough to buy his first laptop, a modest, second hand machine that finally allowed him to expand his expertise. He then enrolled in the Faculty of Technical Sciences in Čačak, Serbia. While studying IT and Software Engineering, he treated the curriculum as a baseline. He was already learning C# through aggressive self study long before the first lecture.

The Handheld Foundry

Continuing his "mobile first" philosophy, Igor engineered a fully functional Content Management System (CMS) entirely on his phone. Developed using vanilla HTML, CSS, JS, and PHP, the system featured a comprehensive control panel for real time site orchestration. It provided a robust content workflow allowing him to create and search pages, edit their source code or templates on the fly, and manage a modular component and widget architecture. He even engineered a specialized Status Toggle to switch the site between online and offline modes instantly.

Detailed records and visual evidence of this and other early works are preserved in his notable projects archive .

Interop: The Performance Benchmark

In his Computer Architecture course, the professor offered an elite alternative to the standard theory exam to develop a functional benchmarking utility from scratch. While the majority of the cohort opted for the test, Igor chose to build. The result was BenchPro . Using C# and Win32 Interop, he engineered a multi threaded suite that utilized Monte Carlo simulations to stress test CPU throughput. By pulling real time WMI telemetry (L2 and L3 cache, core counts), he bridged the gap between abstract architectural theory and physical silicon performance.

The Unsolved: Overengineering the "Impossible"

By his third year, Igor was already mentoring fellow students and handling freelance development. He consistently sought challenges that exceeded standard academic boundaries. This drive culminated during his Operations Research course, where he accepted a faculty problem that had gone unsolved by ~500 students for five years. With a strict two week deadline, Igor did not just solve the math. He architected a full desktop suite using Delphi and raw Win32 APIs. He engineered a custom GDI rendering engine, proprietary binary file formats (.cxf, and .cxc), and a system for Compromise Programming. The result, CalculusEx , earned a perfect 10 (A) and finally closed the long standing challenge.

Logic Debugged: The Self Validating System

Throughout his degree, Igor maintained a "curriculum plus" approach. While excelling in Advanced OOP, Software Engineering, and Database Programming, he consistently achieved 100/100 scores on all programming related coursework. This was so consistent that he was always exempted from final oral exams, his technical performance had already exhausted the grading scale. During this time, he continued his autonomous exploration beyond the classroom, exploring advanced software architectures and emerging tech stacks that went far beyond the classroom, effectively turning his formal education into a baseline for his personal innovation.

The Vanilla Rebellion: Zero Dependency Architecture

By 2015, Igor realized that off the shelf platforms were too bloated for his performance standards. He performed a total "architectural purge", rebuilding his entire portal from the ground up in vanilla PHP, HTML5, JavaScript, and CSS. Rather than relying on third party plugins, he engineered a custom CMS from scratch, featuring:

• Proprietary Widget System: A modular approach to sidebar content, including social integration and custom search modules.
• Native Traffic Analytics: A custom view tracking engine that logged and displayed real time engagement (e.g., 88 views) for every post without external dependencies.
• Custom Comment Engine: A native, lightweight discussion system built directly into the PHP backend, including a custom CAPTCHA system.
• Advanced Blogging Architecture: Full CRUD functionality for posts, supporting specific categories (e.g., "music"), tags, and precise second level timestamps.
• Search & Discovery Hub: An integrated search engine with a "Recent Searches" history layer that turned user queries into discoverable tags.
• Extreme Optimization: The system was so lean that page generation times were clocked as low as 0.026s, proving that high performance architecture is a product of efficient logic, not heavy hardware.

Remains of it are available in his public archive .

The Lunar Dawn

Before the dominance of modern frameworks, Igor architected Luna, a unified JavaScript engine designed to simplify complex browser environments. Developed entirely on a mobile device, it was not just a library. It was a holistic abstraction layer that consolidated DOM orchestration, network requests, and state management into one predictable interface. Key architectural milestones included:

• Predictable System Logic: Custom type guards that brought deterministic structure to JavaScript’s dynamic runtime.
• Unified UX Utilities: Integrated handling of asynchronous data, dynamic styling, and viewport effects.
• State Aware Routing: Early implementation of URL driven state management for browser based applications.

Luna marked the transition from writing features to designing developer ecosystems, establishing the principles of DX and performance that drive his work today.

Remains of it are available in his public archive .

The Zero Studio Thesis: NeoVisio Ecosystem

For his final academic milestone, Igor engineered a comprehensive app store and distribution platform exclusively on his phone, an LG L70. He set this as a personal "stress test" choosing a programming heavy thesis that none of his peers attempted. Despite having zero prior exposure to Java alongside the Android API, he taught himself the entire stack on the fly. Because his laptop could not support modern IDEs like Android Studio or Visual Studio Code, the entire ecosystem (PHP/MySQL backend, REST API, and Android client) was developed on the phone itself via a simple text editor and AIDE.

The NeoVisio Ecosystem functioned as a synchronized proprietary App Store. The client mirrored the Web portal's functionality, with the addition of performing local applications scans to cross reference versions with the server via REST, managing the full installation lifecycle, and syncing user ratings and metadata in real time. Igor engineered the client to handle network state detection, a custom download manager, and automated homescreen shortcut injection, maintaining perfect feature parity between the browser and the native OS. The client's source code was later released to the public and is available on its official repository, NeoVisio AppStore .

Historical Recognition
The platform's impact extended beyond the academic environment, eventually being indexed by global software discovery platforms as a viable third party distribution alternative. Documentation and community preserved snapshots of the ecosystem's public release can be found on AlternativeTo and 2 related applications lists ( Software and App Discovery and APK Sources ).

The Polyglot Architect

Over the past decade, Igor has evolved into a versatile polyglot architect, mastering 18+ programming languages through the necessity of solving complex, real world engineering challenges. His freelance career is defined by development of high performance, proprietary systems across sectors like healthcare, HR, and luxury retail.

View Full Freelance Portfolio & Project Deep Dives

Read Client Testimonials & Success Stories

The Interconnected Ecosystem: Open Source as Necessity

Igor began creating open source projects to build tools and fixes that did not yet exist. His contributions, from bug fixes to architectural refinements, have since been adopted by developers and companies globally. He believes that if a system does not function properly, it is his responsibility to ensure it does. This has resulted in a connected ecosystem of libraries and concepts that rely on one another for systemic integrity.

Engineering foundational open source tools that solve systemic development challenges, with a focus on Software for Software:

• Standardization & Interoperability: Developing high integrity polyfills (like scrollend) and Astro integrations to bridge engine gaps and ensure cross platform consistency.
• Domain Specific Languages (DSL): Architecting the ADBT ecosystem and the Aria compiler to provide a formal, automated framework for ad block filter maintenance.
• Developer Experience (DX): Creating widely adopted VS Code extensions and themes designed to reduce cognitive load and streamline high frequency development workflows.
• Deterministic Logic: Building performance critical engines like Zep (debounce) and Commoji (semantic tagging) to standardize execution lifecycles and version control.
• Modular Architecture: Developing zero dependency TypeScript/JavaScript helpers (like Zitto) to prioritize lean, deterministic logic across Node, Deno, and Bun environments.