Category: Software

Revolutionizing Research: Introducing a Web-Based Notebook Integrated with AI and PDF Support | February 19 2026, 16:19

I’ve further developed a new tool for myself for working with information and organizing it. The main idea is a web-based notebook for research, studying subjects, working on them, integrated with AI and PDF support.

The main problem with typical PDF readers and notes is that the context is lost as soon as you switch to a new tab. In my tool, each text fragment or PDF becomes a node in a “live” hypertext tree, which I can access from multiple computers at any time.

Work process:

– Contextual AI. I can ask the AI to clarify complex passages right within the document. The explanation stays right where the question was asked. Moreover, it is a separate document, linked to the specific spot in the source. When clicked, you see both the original and the explanation on the screen at the same time.

– Panels instead of windows. If the explanation itself requires clarification, a new panel opens to the right. This allows for an endless chain of queries, never losing the place in the original text. That is, you see several panels at once, and unnecessary ones can be closed.

– PDF support. I can upload a PDF, select an area on the page (e.g., a complex diagram or a list of authors), and the LLM instantly extracts data, supplements, or explains them. The explanation is attached to the spot where it was requested, just like with non-PDFs.

– Nested annotations. My comments are not just static text. They can contain their own PDFs, links, and further sub-tasks for AI, maintaining a depth of nesting that reflects how we actually think.

This is not just a file storage system, but an “engine” for building knowledge.

The tool suits me personally very well, but perhaps it only solves my specific tasks. What do you think, would something like this be useful to others? Would it be useful to you? Should I develop the project into a fully-fledged product and give it to other users for testing?

Interactive Text Enhancer: A Tool for Embedding Clarifications | February 12 2026, 16:11

I whipped up this thing in just an hour. Do you think anyone besides me needs it?

Here’s the idea. Take any text – a Wikipedia article, for example. Highlight any segment, say something unclear. The LLM gives us an explanation, and instantly inserts a box right in the text which you can click to open the explanation. In this explanation, there might be something unclear too. We highlight it with the mouse from this explanation, and a box appears there too. This continues until everything is clear. All the boxes remain in the text, so you can always return to them. So, if the idea was unclear to me, maybe it will be to others, and then a ready link with explanations will come in very handy. The result can be shared with colleagues.

For explanations, not just the fragment is used, but also the context. For example, otherwise, the highlighted word Terrier would yield text about a dog breed, not about the search system.

Exploring Algorithmic Stylization in Plotter Art: A CMYK Fractal Journey | February 01 2026, 04:18

Now that I have a plotter, I am fully experimenting with ways of algorithmic image stylization. To achieve what is attached, a Minimum Spanning Tree algorithm was used. Essentially, it converts an image into stochastic rasterization – that is, where it’s darker, there are more dots, and then connects the dots with lines so that all points are connected in a single network, the total length of all lines is minimal, and there are no closed loops (meaning it’s precisely a “tree” with branches, not a “web”).

And this is what I do with each of the CMYK channels, then combine the result into a color picture. On this picture, there seem to be no other colors except for these four CMYK ones, but in reality, there is a bit because some smoothing has crept in.

Printing such on a plotter, of course, is difficult, I will be waiting forever, but I am getting the hang of it, I have already printed the first color picture (it turned out so-so. Well, the first pancake is always lumpy. Comments below)

A Decade at EPAM: Thriving Through Change and Challenge | January 05 2026, 13:43

10 years at EPAM.

I would have never thought that I would enjoy working in the same place for an entire decade. What’s the secret? At EPAM, I am always evolving: projects change one after another, never letting me get bored.

I am currently on a project at a giant company: over 100 thousand employees and revenue of 30 billion dollars. Before this, it was the automotive industry — a behemoth with a staff of 175 thousand and a turnover of 150 billion. Somewhere around, there was a contract with a company of 80 thousand employees and 35 billion in revenue. True scale and genuinely serious challenges. And earlier, there were cosmetics brands, biotech, and the oil sector. In total, more than 20 projects of various calibers. Despite having over 100% workload every single day. And it seems that this year, I had more vacation than usual, yet still less than I could have taken. I traveled to Costa Rica, Mexico, Seattle, Antalya.

The point is, at each new place you learn something, sometimes from scratch. And that’s freaking awesome. It gives much more energy than if I had been “rooted” in any of these corporations for all 10 years. Perhaps, from a purely financial standpoint, people who stayed in one place at these companies earned more than me, but money isn’t the priority if it means sacrificing interest and enthusiasm. Living life at a job from which you are utterly exhausted is a questionable pleasure.

Last year at EPAM was maximally intense, and I sincerely hope that 2026 will not slow down.

How Gemini Transformed Low-Resolution Previews into High-Quality PDFs | January 03 2026, 14:18

How unexpectedly useful Gemini turned out to be in a simple task – to create a high-quality PDF from a low-resolution preview. Nano Banana Pro was used, meaning, the output was raster, not vector. Look at the difference. Very often it is impossible to even make out the text, so from time out it turned into time dute;-). But overall, not bad.

Visualizing Volleyball Plays: A Glimpse into My App’s Functionality | January 01 2026, 21:37

Here is actually a quick screen capture of how my app for creating and visualizing volleyball schemes works.

Implementation details here: https://www.facebook.com/raufaliev/posts/pfbid0njrqH8oLcWGFsZcgE5o2pj3NcDNaYSQeCMY6twXNbZn6dc38m9kjhsBqA4YsMozcl

Designing 3D Volleyball Training Tools on the Fly | January 01 2026, 21:21

What I did on the plane to/from vacation and sometimes in between: 3D visualization and editing volleyball schemes for Nadya (she’s a coach). This court in the attached image freely rotates, players can be placed on it, and the ball and player paths are shown – all in 3D.

The ball’s trajectory is calculated so that it does not cross the net when moving from A to B (Bezier formula). Players can take several poses – right now there are hastily made poses for serve, attack, block, pass/receive. Interestingly, in the code: I had to write a bit of “volleyball brains”. The system itself calculates the ball’s trajectory through Bezier curves so that it always passes over the net. Moreover, the height of the launch depends on the type of action: for an attack, the ball “launches” from a higher point than for a pass. I also added auto-rotation: the 3D model itself turns its face to where, according to the scheme, it needs to pass or run.

The longest and most difficult task was creating the 3D model of a female volleyball player. To generate a realistic volleyball player, I used the tripo3D service. It gave me a model in a neutral pose (for free). Theoretically, you can then use Blender and the Rigify plugin to attach an armature to it and move its arms and legs, which would recalculate the model.

However, in reality, this approach does not work well: the AI-generated model contains a large number of geometric errors, which the renderer forgives but Rigify does not. They can be roughly divided into two types — incorrect polygon normals and issues with non-manifold geometry, which are significantly more challenging to fix. Inside the body, there may be “floating” clusters of polygons or intersecting surfaces. When Rigify tries to calculate weights (which bone affects which part of the skin), this internal noise confuses the algorithm, and as a result, the weights are distributed chaotically (for example, moving the arm might start pulling the mesh on the stomach). Plus, the model is slightly asymmetrical.

Non-manifold is a geometry error where the topology of an object ceases to be correct in terms of a three-dimensional body: edges may belong to more than two polygons, polygons may only touch at vertices or edges without a common volume, and “hanging” surfaces or zero thickness may appear inside the model. Such geometry formally does not describe a closed volume, causing problems with rigging and deformations. Moreover, the model needs to be simplified because millions of polygons are not needed for rendering in real-time in a browser.

I fixed these using MashLab, additionally refining by hand (“with a file”). In the end, the model turns out slightly different from the original almost everywhere. The original model had “skin” in the form of textures – the face, shirt, and shorts had to be colored. How to transfer all this to a simplified model? For that, there’s a special operation in Blender called Baking. This also involves some tricks. In the end, it didn’t transfer perfectly, but perfection isn’t necessary yet.

Next, we attach the armature to the “joints”, and after about three hours of figuring out why everything does not work as it should, it finally worked. I made four poses, and now each circle (player) can be told which pose it is in.

I’ll also need to make dynamic changes to the uniform colors – that shouldn’t be difficult. There’s also an idea to transfer poses from photographs – this is more complicated, but generally feasible. Using MediaPipe/AlphaPose, you can detect key points in 2D, then some models like HMR/HybrIK can “lift” flat coordinates into 3D space, outputting relative joint rotation angles. The resulting data can be attempted to be projected onto a Rigify skeleton. Since the proportions of the generated volleyball player and the person in the photo may not match, that’s exactly why Inverse Kinematics (IK) is used. This part is quite complex, but overall it’s not strictly necessary – just interesting to figure out and make something functional.

Video in the comments

Crafting a Custom Volleyball Play Editor | December 23 2025, 21:39

Tomorrow is the flight to Costa Rica, and here I am creating (or created) a volleyball playbook editor for Nadya. As a coach, she prepares for her sessions and leaves behind hundreds of pages of text with diagrams on each page. The text is handwritten, and theoretically, it’s simple to convert to a digital format, but converting the diagrams into high-quality vector format is exhaustive—there are so many. So, I decided to make the software yesterday. And today, the first version is ready to use. This is a diagram editor, somewhat remotely similar to a diagram editor. Also got to dig into the fabric framework.

The process looks like this. Gemini/ChatGPT through an API can convert hand-drawn diagrams into a structure that my program understands. Then we open this file in the program, and tweak a bit if necessary. Or maybe even redraw from scratch – for simple diagrams, it’s even easier. There are four types of objects – player, cone, target, text. Any can be connected with arrows, solid or dashed, labeled with text or numbers or not, in any chosen color, straight or curved. If you touch an object with the mouse, all connected arrows will follow.

The result can be saved in a file. You can open a template and based on it create something new. You can generate a Python script – yesterday it was still relevant, today generally not needed anymore – high-resolution SVG/PNGs are made directly from this app (yesterday they were made separately in Python).

It’s clear why you wouldn’t just ask Gemini/ChatGPT to do something for ready-made vector editors: firstly, they are too flexible and limiting LLM’s imagination is quite difficult. As a result, you get stylized, unusable images. Here, instead, there is a framework consisting of four objects and that’s all, LLM knows about it and only generates what can be represented with them. Secondly, this framework operates with objects, not elementary vector primitives.

Overall, this is the first step towards my idea of an automatic diagramming system based on descriptions. Where you give an LLM a diagram description, and it consistently generates what is written in the description, and if you make any corrections, they will be taken into account during regeneration.

Decoding the Beast: Migrating from Excel to Code | December 17 2025, 18:56

We’ve all encountered it — the “Main Excel Spreadsheet Managing the Business.” The very one B2B companies use to calculate million dollar quotes. It has 12 tabs, 1000+ nested formulas, and zero documentation. For ten years, it had “quick fixes” slapped on and constants hidden away. It’s no longer just a file, but a living organism that no one fully understands except for the guy who quit years ago. That’s how puzzled I was. Moreover, there was uncertainty whether even half of the formulas were needed, or if they were vestiges of the past.

Typical cell:

=IF($D11=$D10,””, IF(ISNUMBER( INDEX(Data!$T$10:$U$17,

MATCH(TabCalc!$F11,Data!$T$10:$T$17,0),2)),

INDEX(Data!$T$10:$U$17, MATCH(TabCalc!$F11,Data!$T$10:$T$17,0),2),

INDEX(TabProd!$C$8:$U$112,TabCalc!$D11,I$1)))

I was tasked with transferring this logic into code so that it was all computed by software. The Excel file seemed to have everything it needed, but in reality — it was a complicated black box. 1069 formulas.

The challenge was in how to translate a thousand interdependent formulas into clean code without losing any edge cases.

Here’s what I ended up doing.

Instead of rewriting everything from scratch at once with uncertain prospects of bug proliferation, I used a strategy of lazy computations and mocks.

I built a structure on Groovy that mimicked Excel’s behavior. Each computation (from a cell) I defined as a function that executed only when it was called. And the functions were a multidimensional dictionary.

I started from the end of the computation graph: from results to inputs. If a formula depended on something I hadn’t yet written, I “mocked” it in the code, simply substituting the value from the Excel sheet.

Bit by bit I replaced these mocks with real logic. Comparing the output of my code to the Excel at each step, I could clearly see where my logic diverged.

In other words, I moved from the result to the input data. At each step, it was clear which mocks needed to be turned into code, and I could compare version +1 with version -1 — the result had to match. As soon as all mocks were replaced with calls — the task was done.

The real “secret ingredient” was the dynamic nature of Groovy for creating a multidimensional map of functions. Instead of static variables, I used a deeply nested structure, where each “leaf” was a closure. This allowed access to any part of the table — be it an input parameter, a config constant, or a complex intermediate result — through a simple, unified syntax, and some components were dynamic.

Here’s an example:

conf[“group”] = { x -> [“a”, “b”, “c”] }

conf[“group”]().each {

calculate[“Group”][“Subgroup”][it][“TotalQuantity”] =

{

x -> calculate[“Group”][“Subgroup”][it][“Someparameter”]() * conf[“someConstant”]()

}

}

Using dynamic keys and closures, I could iterate through product groups or data sets. Since these were dynamic functions, not stored values, the entire system worked like a living graph of dependencies.

Testing was possible right from the start of transferring the formulas. The charm was that you were kind of addressing a cell through syntax like calculate[“Totals”][“A”](), but in reality, you were launching an entire tree of calculations at that moment. And this was incredibly convenient for debugging.

In two weeks, the “Black Box” was transformed into a transparent, modular library with clear logic, which produced exactly the same result as the original table.

P.S. Of course, all the data in all the screenshots are thoroughly obfuscated, or rather, written from scratch for this text.