DEV Community: Sanskar

FrameTrellis v1.3.1: Fixing Media-Bin Bugs and Strengthening Video Editor Reliability

Sanskar — Fri, 30 Oct 2026 11:42:31 +0000

FrameTrellis v1.3.1: Fixing Media-Bin Bugs and Strengthening Video Editor Reliability

FrameTrellis v1.3.1 is now available as a stable release on GitHub.

This update focuses on improving media-bin interactions, handling missing media more predictably, and preventing previously discovered problems from returning.

FrameTrellis is a free, open-source, local-first desktop video editor built with C++20, Qt 6/QML, MLT, and FFmpeg.

Unlike a feature-focused release, v1.3.1 concentrates on stability and correctness.

Why This Update Matters

Video editing applications are complex.

Even a relatively small user-interface problem can interrupt an editing workflow, especially when working with imported media files, missing assets, and multi-track timelines.

A reliable editor must do more than support editing operations. It must also handle unexpected application states correctly.

That's the motivation behind FrameTrellis v1.3.1.

1. Fixing Media-Bin Interaction Errors

One of the problems addressed in this release involved a QML delegate lookup.

Selecting or double-clicking a tile in the media bin could produce the following error:

ReferenceError: grid is not defined

The problem came from how the tile attempted to access its containing GridView.

The updated implementation resolves the owning GridView through its attached view property.

This fixes the problematic lookup and helps make media-bin interactions more predictable.

2. Improving Missing-Media Handling

Media files can become unavailable when they are moved, renamed, or stored on disconnected drives.

Video editors need to handle these situations carefully.

Previously, pressing Enter while an unavailable media tile had keyboard focus could attempt to append that source to the timeline.

In v1.3.1, this interaction has been corrected.

When a missing or offline media item is focused, pressing Enter now requests the media relinking workflow.

The result is a more appropriate response to unavailable source files.

3. Strengthening GUI Regression Tests

Fixing a bug is only part of maintaining software.

The next challenge is preventing the same bug from reappearing in future development.

For this release, I added a GUI regression assertion that checks for QML warnings during media-bin tile interactions.

This helps identify problems that might otherwise remain unnoticed during ordinary testing.

The maintenance branch also uses automated Linux builds, sanitizer testing, formatting checks, packaging workflows, and Windows clean-host verification.

These checks help improve confidence in the release, although automated testing cannot replace testing on every physical system.

4. Preserving Project Compatibility

FrameTrellis v1.3.1 retains the existing project format from v1.3.0.

No project migration is required.

The editing feature set and MP4 export capabilities also remain unchanged.

Importantly, this release does not introduce experimental subtitle editing, opacity, volume or transform keyframes, or newer project formats currently being developed separately.

This is intentionally a focused maintenance release.

5. What FrameTrellis Already Supports

FrameTrellis provides a growing collection of practical video editing capabilities:

Multi-track video and audio editing.
Clip trimming, splitting, and timeline operations.
Timeline snapping and transitions.
Audio waveform and volume controls.
PNG-based title overlays.
Undo/redo, autosave, and project recovery.
MP4 exporting with H.264 video and AAC audio.
Local media processing without mandatory cloud services.

The application is designed to keep media files and editing workflows under the user's control.

6. Downloading FrameTrellis v1.3.1

Official Windows x64 downloads include:

Windows Installer

FrameTrellis-1.3.1-windows-x64-setup.exe

Portable ZIP

FrameTrellis-1.3.1-windows-x64.zip

Windows 10 version 1809 or later and Windows 11 x64 are supported.

Linux users can build FrameTrellis from source.

Prebuilt Linux packages and official macOS support are not currently provided.

Security note: The Windows packages are not digitally signed. The release provides SHA256SUMS.txt so users can verify downloaded files.

The release also includes an SPDX software bill of materials and source archives for bundled third-party components.

7. What's Next?

FrameTrellis development continues beyond v1.3.1.

Areas under development include more advanced editing controls, timeline workflows, subtitle capabilities, keyframes, and additional usability improvements.

These are development directions rather than features promised in this release.

My goal is to continue improving FrameTrellis through practical features, careful testing, and open-source collaboration.

Explore FrameTrellis

Download the stable release:
https://github.com/sanskarIN/frametrellis/releases/tag/v1.3.1

GitHub repository:
https://github.com/sanskarIN/frametrellis

Official website:
https://sanskarin.github.io/frametrellis/

Report issues or contribute:
https://github.com/sanskarIN/frametrellis/issues

Support development:
https://buymeacoffee.com/SanskarCodes

Final Thoughts

FrameTrellis v1.3.1 is a small but meaningful stability update.

Software development isn't only about introducing new features. It's also about making existing functionality dependable.

For a video editor, predictable media handling and reliable user interactions are foundational.

FrameTrellis — Build openly. Edit locally. Keep control of your work.

If you're working on multimedia applications or open-source desktop software, I'd welcome your feedback.

What do you think matters most in a video editor: new features, timeline performance, or reliability?

RepoDNA v1.4.5: Building Smarter Offline Repository Intelligence

Sanskar — Fri, 30 Oct 2026 09:34:30 +0000

RepoDNA v1.4.5: Building Smarter Offline Repository Intelligence

Understanding a software repository is more than reading its README or scanning its directory structure.

Developers need to understand architecture, dependencies, historical changes, code quality signals, and the evidence behind technical conclusions.

That's why I've been building RepoDNA, an open-source, local-first repository intelligence and code archaeology platform.

Today, I'm sharing two stable releases:

RepoDNA v1.4.4 — October 28, 2026

RepoDNA v1.4.5 — October 30, 2026

Together, these releases represent another step toward more reliable, locally evaluated, evidence-driven repository analysis.

What is RepoDNA?

RepoDNA helps developers analyze software repositories and understand how their codebases work.

Its existing capabilities include:

Repository architecture and dependency analysis
Git history and code archaeology
Code quality and complexity signals
Security, testing, and documentation signals
Interactive analysis and Project DNA reports
CLI, desktop, browser, and CI workflows
Optional AI-assisted explanations

The central principle is simple: analysis should be supported by inspectable evidence.

v1.4.4: Introducing Native Evidence Intelligence

One of the most important additions in v1.4.4 is the optional native explanation provider.

Instead of requiring an external language-model API for every explanation, RepoDNA now supports an offline, keyless, built-in evidence digest.

This capability is extractive, meaning it works with evidence obtained from repository analysis rather than generating unrestricted natural-language responses.

The release also introduces a small CPU-only evidence-relevance ranker.

Developers can prepare labeled examples and train a local ranking checkpoint without downloading third-party model weights.

The trained ranker can optionally reorder the evidence selected for native explanations.

Better evaluation

v1.4.4 also introduced retrieval-quality measurements, including:

Mean Reciprocal Rank (MRR)
Precision@k
Recall@k
NDCG@k

The system compares trained ranking results against the original evidence ordering using repository-disjoint holdout data.

This gives developers a more useful way to evaluate whether local ranking is improving evidence retrieval.

Better findings review

The Findings interface now supports confidence-based filtering and expanded export capabilities.

Filtered findings can be exported in CSV, JSON, or Markdown formats.

These outputs help maintainers inspect findings, review supporting evidence, and incorporate the results into their own development workflows.

Additional improvements strengthen browser import safety, local API validation, package-release integrity, and reliability.

v1.4.5: Reproducibility and Evaluation

v1.4.5 builds on the native evidence-ranking foundation established in v1.4.4.

The focus of this release is not simply adding more ranking features.

It is making ranking behavior easier to reproduce, evaluate, and trust.

1. Deterministic local training

Training is designed to produce consistent outputs even when input dataset rows are shuffled.

The release strengthens validation of evidence identities and repository boundaries.

It also rejects unsafe or ambiguous training data, helping prevent misleading evaluation results.

2. Calibration diagnostics

v1.4.5 adds evaluation diagnostics including:

Brier score: Measures error in relevance probability estimates.

Binary log loss: Evaluates probability predictions against labeled relevance outcomes.

Calibration bands: Help examine whether estimated scores align with observed relevance frequencies.

These evaluate evidence-label relevance, not the factual accuracy of a generated answer.

3. Answerability threshold evaluation

The release introduces offline analysis of hypothetical answerability thresholds.

This helps explore how different thresholds would affect incorrect acceptance and missed answerable questions.

Importantly, these measurements are diagnostic. They do not automatically enable runtime abstention.

4. Stronger regression coverage

Additional tests cover training CLI behavior, checkpoint generation, deterministic output, file overwrite protection, and repository leakage prevention.

The objective is to make the native evidence-ranking system more predictable across supported development environments.

Why Local-First Matters

RepoDNA is designed around a local-first workflow.

Core repository analysis can be performed without uploading source code to a hosted analysis service.

The native extractive explanation capability does not require an external AI API key.

For developers working with internal projects, large codebases, or offline environments, those properties are particularly useful.

And because RepoDNA is open-source, developers can inspect the implementation and evaluate the results themselves.

How to Try RepoDNA

Option 1: Browser

Try the web application:

https://sanskarin.github.io/RepoDNA/

Option 2: Install the CLI

npm install --global @sanskarin/repodna

Then analyze a repository:

repodna analyze .

Option 3: Desktop

Download the latest release for Windows, Linux, or macOS from GitHub.

https://github.com/sanskarIN/RepoDNA/releases/tag/v1.4.5

What's Next?

These releases strengthen the groundwork for continued development of native repository intelligence.

The focus remains on reproducible analysis, evidence quality, useful developer workflows, and transparent limitations.

RepoDNA is not trying to replace software engineers' judgment.

It is being built to help developers make better-informed decisions about their codebases.

Explore and Contribute

GitHub: https://github.com/sanskarIN/RepoDNA

Latest stable release: https://github.com/sanskarIN/RepoDNA/releases/tag/v1.4.5

Web application: https://sanskarin.github.io/RepoDNA/

More projects: https://sanskarin.github.io/

If you're interested in developer tooling, repository analysis, Rust, or local-first software, I'd welcome your feedback and contributions.

RepoDNA — Understand your codebase. See its DNA.

FrameTrellis v1.3.0: Safer Editing, Smarter Media Management

Sanskar — Sun, 25 Oct 2026 11:34:38 +0000

FrameTrellis v1.3.0: Safer Editing, Smarter Media Management

Today, I'm sharing FrameTrellis v1.3.0, a new stable release of my open-source desktop video editor.

This update focuses on editing reliability, file safety, improved media discovery, and better tools for understanding project state.

FrameTrellis is built with C++20, Qt 6/QML, MLT, and FFmpeg.

It is designed around a simple principle: video editing should remain local, transparent, and under the user's control.

Why this release matters

Video editing applications manage important creative work, often involving large files, complex timelines, and multiple source assets.

Small mistakes in file handling, timeline calculations, or rendering can have significant consequences.

For v1.3.0, I focused on making those underlying workflows more dependable.

1. Protecting projects and original media

One of the most important improvements is stronger protection against unintentional file replacement.

FrameTrellis now includes additional checks designed to prevent project-saving and export operations from overwriting important files.

The release also strengthens duplicate-media handling and detects external changes to source files, including modifications that do not change file size.

These improvements help make editing workflows more predictable.

2. A searchable media bin

Working with imported video, audio, and images becomes more complicated as a project grows.

The media bin now supports searching by filename or path and filtering by media type.

This makes it easier to find the assets you need without modifying the underlying project media.

3. Precise timecode navigation

FrameTrellis v1.3.0 adds a Go to Timecode dialog.

Press Ctrl+G, enter a valid SMPTE timecode, and navigate to the corresponding sequence frame.

This is particularly useful when returning to specific editing positions or working with precise timing references.

4. Improved project inspection

The headless renderer now supports read-only project inspection:

frametrellis-render --inspect-project --project my-project.ftproj

This command can report:

Video and audio track counts
Timeline clip counts
Referenced and unused media
Missing assets
Sequence duration

It provides diagnostics without starting a full render or exposing complete source paths.

For developers and technical users, this creates opportunities for automated checks and reproducible workflows.

5. Stronger rendering safeguards

Export reliability is another major focus of this update.

The release improves rendering destination validation, cancellation command handling, and helper-process message limits.

Additional regression tests cover Unicode export destinations, concurrent engine initialization, and timeline validity.

These changes prioritize correctness and predictable behavior.

6. A better documentation experience

Documentation is an important part of an open-source project.

The FrameTrellis documentation website now includes searchable guide navigation, section links, copyable code examples, and accessibility improvements.

The goal is to make it easier for both users and contributors to find the information they need.

What FrameTrellis already offers

Alongside the new v1.3.0 improvements, FrameTrellis supports multi-track video and audio editing, clip trimming and splitting, timeline snapping, transitions, PNG title overlays, undo/redo, autosave, and MP4 export.

The application is local-first.

There is no account requirement, cloud-upload dependency, subscription, or telemetry.

Availability and limitations

Official v1.3.0 downloads are available for Windows 10/11 x64 as an installer and portable ZIP.

Linux users can build the project from source. macOS is not yet supported.

Export currently supports MP4 using H.264 video and AAC audio. Editable title layers, keyframes, subtitles, and additional formats remain future work.

The Windows packages are unsigned, so users should verify the published SHA-256 checksums.

Explore FrameTrellis

GitHub repository:

https://github.com/sanskarIN/frametrellis

v1.3.0 stable release:

https://github.com/sanskarIN/frametrellis/releases/tag/v1.3.0

Official website:

https://sanskarin.github.io/frametrellis/

Support development:

https://buymeacoffee.com/SanskarCodes

What's next?

FrameTrellis is continuing to evolve.

Future development will focus on broader editing capabilities, workflow improvements, platform support, and greater reliability.

For now, v1.3.0 represents another step toward dependable, local-first, open-source video editing.

If you're interested in native desktop development, multimedia systems, C++, or open-source applications, I'd welcome your feedback and contributions.

Build openly. Edit locally. Keep control of your work.

— Sanskar

What If the Next Operating System Had No Apps? The Future of Intent-Native Computing

Sanskar — Sun, 25 Oct 2026 07:38:47 +0000

What If the Next Operating System Had No Apps?

The Future of Computing Might Not Be Applications, but Intent.

We have spent decades improving software.

Faster applications. Better programming languages. More powerful operating systems. Increasingly intelligent AI assistants.

But there is one fundamental assumption we rarely question:

Why do humans have to choose the applications before computers can understand what they want to accomplish?

Think about it.

You want to create a video, so you open a video editor.

You want to analyze information, so you open a spreadsheet.

You want to build software, so you open an IDE.

You want to automate a workflow, so you connect several different tools.

The computer has enormous processing power, yet much of the responsibility for organizing the work still belongs to us.

What if we reversed that relationship?

The Radical Idea: Software Generated Around Intent

Imagine entering this request:

"Take my project folder, analyze its architecture, identify potential problems, create a dependency visualization, and generate a report."

A conventional workflow might require several applications, scripts, and manual steps.

An intent-native computer could approach the problem differently.

First, it understands the objective.

Then it identifies the required capabilities.

Next, it creates an execution plan, requests the necessary permissions, and assembles an interface for the task.

The result isn't necessarily a newly installed application.

It might be a temporary workspace built from existing reusable components.

The Architecture Behind the Idea

Conceptually, such a system might have six layers:

Intent interpretation: Translate the user's request into a structured objective.
Planning: Identify dependencies, constraints, and necessary capabilities.
Permission management: Ensure each operation is authorized.
Capability execution: Run existing tools, libraries, and services.
Dynamic interface composition: Present controls appropriate to the task.
Verification and recovery: Record outcomes, surface uncertainty, and support rollback where possible.

A request could be represented like this:

{
  "intent": "analyze_project",
  "source": "./my-project",
  "requirements": [
    "dependency_graph",
    "architecture_report",
    "security_review"
  ],
  "execution": {
    "preferLocal": true,
    "networkAccess": false,
    "requireApprovalForChanges": true
  }
}

This example is a conceptual specification, not a working operating-system API.

Notice something important: the request describes the desired result and its constraints, not a particular application.

Does This Mean Traditional Apps Will Disappear?

Not necessarily.

Applications are valuable because they offer predictable workflows, specialized interfaces, and mature functionality.

Professional video editors, CAD tools, debuggers, and scientific software cannot simply be replaced by a text box.

But perhaps the long-term opportunity is to make applications optional entry points rather than mandatory boundaries.

Developers could expose individual capabilities.

Users could combine them.

AI could assist with translating goals into safe, inspectable workflows.

The Hardest Problem Isn't Intelligence

It's trust.

Suppose a computer understands the instruction:

"Clean up my project."

Does that authorize deleting files?

Renaming folders?

Changing dependencies?

Uploading source code to a remote service?

Of course not.

An intent-native system would need explicit capability boundaries, permission checks, reversible operations where feasible, and reliable records of what actually executed.

It must also distinguish an AI-generated plan from an operation that genuinely ran.

Otherwise, we would merely replace application complexity with automation risk.

Could This Work Without the Cloud?

At least parts of it could.

A local-first implementation might combine:

On-device language models for interpreting requests.
A deterministic execution engine for carrying out approved operations.
Sandboxed components for isolated capabilities.
Local storage for user data and execution history.
Optional cloud services when explicitly authorized.

The difficult engineering work would be making these parts reliable, secure, interoperable, and efficient.

The Bigger Question

What if the most important innovation in computing isn't another operating system feature?

What if it's changing what an operating system considers its fundamental unit of work?

Today, we primarily organize computing around applications, windows, files, and processes.

Perhaps future systems could also organize computing around goals, capabilities, permissions, and verified outcomes.

That wouldn't eliminate programming.

It could create entirely new opportunities for programming language designers, operating-system engineers, and developers building reusable software components.

Maybe the future of computing isn't choosing the right application.

Maybe it's describing the result you want—and having the computer safely assemble the tools to get there.

This remains a vision, not a solved engineering problem.

But I think it's a question worth exploring.

Developers: Would you use an operating system built around intentions instead of applications? Or do traditional applications offer something we should never give up?

Exploring the future of systems programming, local-first software, AI engineering, and developer tools.

GitHub: https://github.com/sanskarIN

Website: https://sanskarin.github.io

RepoDNA v1.4.3: Better Desktop Experience, CSV Exports, and Stronger Release Security

Sanskar — Fri, 23 Oct 2026 11:41:29 +0000

RepoDNA v1.4.3: Better Desktop Experience, CSV Exports, and Stronger Release Security

RepoDNA v1.4.3 is officially available!

This stable release introduces improvements to the desktop experience, file exploration, findings exports, browser-based analysis, and release security.

If you're new to RepoDNA, it's an open-source, local-first repository intelligence and codebase archaeology tool designed to help developers understand software repositories beyond their directory structures.

GitHub: https://github.com/sanskarIN/RepoDNA

Web application: https://sanskarin.github.io/RepoDNA/

What is RepoDNA?

When you open an unfamiliar repository, understanding its architecture and history can take significant effort.

Reading individual files is useful, but it rarely gives you the complete picture.

RepoDNA helps explore questions such as:

How is this repository structured?
Which components and dependencies are important?
Where are the complexity and change hotspots?
What does the Git history reveal?
Which findings deserve further investigation?

The goal is to transform repository data into understandable, evidence-backed insights.

1. Introducing the What's New experience

One of the most visible additions in v1.4.3 is a dedicated What's New page.

The application can now display release highlights directly from its bundled changelog.

After an installation or update, a dismissible first-launch announcement introduces the current version's changes.

Importantly, this announcement works offline.

The goal is simple: developers should be able to discover what changed without searching for release notes separately.

2. A more practical desktop window

Previously, the Windows desktop application could occupy nearly the entire screen when launched.

Version 1.4.3 improves the default desktop startup experience.

The application now opens in a smaller, centered, resizable window.

This makes it easier to work with RepoDNA alongside an editor, browser, terminal, or other development tools.

3. Export filtered findings to CSV

RepoDNA v1.4.3 introduces CSV export for filtered findings.

You can filter the Findings view and export all matching results, including those beyond the currently visible page.

The export also adds protections against potentially dangerous spreadsheet formulas.

This makes CSV exports more suitable for review, sharing, and further analysis.

4. Better file exploration

The Files explorer now includes additional state-based filters:

Generated files
Vendored files
Binary files
Skipped files
Ordinary files

These work alongside existing language, category, and path filters.

When exploring complex codebases, distinguishing source files from generated or vendored content can make the analysis easier to navigate.

5. More reliable browser-based analysis

Browser-based repository analysis is another focus of this release.

Version 1.4.3 improves:

WebAssembly engine discovery
Analysis progress events
Worker callback handling
Export filename normalization
Recovery from temporary browser database failures
Validation of recent-analysis session data

These changes strengthen the local-first browser experience.

You can explore the web application here:

https://sanskarin.github.io/RepoDNA/

6. Security and release integrity

A significant amount of work in this release happened behind the scenes.

Version 1.4.3 strengthens package publication and installer verification, including dependency checks, Windows archive filename validation, checksums, and release artifact inventories.

The release process also performs additional validation before publishing packages and creating the final GitHub release.

These improvements are intended to reduce packaging mistakes and improve distribution reliability.

7. Other reliability improvements

Several additional changes focus on correctness and predictable behavior.

The application now handles malformed local server responses more carefully, protects against invalid session state, improves exported filenames, preserves finding display order when identifiers repeat, and refines local web-interface token handling.

These fixes may not be immediately visible, but they improve the overall experience.

Download and install RepoDNA v1.4.3

RepoDNA provides several ways to get started.

Desktop

Visit the GitHub release and choose the appropriate installer for Windows, macOS, or Linux.

https://github.com/sanskarIN/RepoDNA/releases/tag/v1.4.3

npm CLI

npm install --global @sanskarin/repodna

Run the web interface locally

npx @sanskarin/repodna-web

Browser version

https://sanskarin.github.io/RepoDNA/

The release also includes portable CLI archives, WebAssembly builds, container images, and WinGet manifests. WinGet community installation depends on the manifests being accepted and published.

What's next?

RepoDNA development continues with the same core direction: making codebase analysis more accessible, evidence-grounded, and useful.

Feedback from developers and open-source contributors is valuable for deciding what to improve next.

If you'd like to contribute, report a bug, or suggest a feature, visit the GitHub repository.

https://github.com/sanskarIN/RepoDNA

If you find the project useful, consider giving it a star.

RepoDNA — Understand your codebase. See its DNA.

Built by Sanskar. Open source, local-first, and continuously improving.

LangSteps v1.2.0: TypeScript-Powered Learning, Better Offline Support, and 10 Free Programming Paths

Sanskar — Thu, 22 Oct 2026 16:16:59 +0000

LangSteps v1.2.0: TypeScript-Powered Learning, Better Offline Support, and 10 Free Programming Paths

I'm excited to share LangSteps v1.2.0, the latest release of my free, open-source programming education platform.

LangSteps is designed to make programming education more accessible through structured learning paths, practical examples, interactive learning tools, and browser-based progress tracking.

The complete platform is now publicly available online:

Live website: https://sanskarin.github.io/LangSteps/

GitHub repository: https://github.com/sanskarIN/LangSteps

10 Programming Learning Paths

LangSteps currently includes:

HTML — Semantic markup, forms, accessibility, and web fundamentals
CSS — Layouts, responsive design, Flexbox, Grid, and animations
JavaScript — Modern syntax, DOM, asynchronous programming, and more
React — Components, hooks, and state management
Python — Fundamentals, functions, OOP, and advanced topics
TypeScript — Static types, generics, and type-safe programming
Rust — Ownership, lifetimes, traits, and systems programming
Go — Interfaces, concurrency, testing, and HTTP services
SQL — Joins, transactions, queries, and database fundamentals
C# & .NET — Language foundations, APIs, and ASP.NET Core

All learning paths can be accessed without creating an account.

What's New in v1.2.0?

1. A Stronger TypeScript Foundation

One of the major improvements in this release is the move toward more maintainable TypeScript-powered browser functionality.

The Go, SQL, and C# learning paths now benefit from a shared, typed lesson viewer.

This helps keep navigation, searching, and lesson completion behavior more consistent.

2. Improved Lesson Navigation

The learning experience now includes refinements to:

Previous and Next lesson navigation
Browser history integration
Lesson deep links
Keyboard focus behavior
Lesson searching
Completion tracking

Existing progress records remain compatible, so learners can continue without migrating their saved progress.

3. Expanded Web API Learning Resources

The Web API guide has been improved with 15 searchable APIs.

It includes practical examples, notes about browser permissions, and references to official MDN documentation.

This makes it easier to explore browser capabilities and understand how modern web APIs work.

4. Better Offline Support

LangSteps remains a static, client-first platform.

This release improves the TypeScript-authored service worker and its versioned caching behavior.

Previously cached lessons and supported resources can remain available offline. A first visit still requires an internet connection, and not every external resource is guaranteed to work offline.

5. Better Mobile Experience

Long code examples should not make a learning page unnecessarily difficult to navigate.

v1.2.0 includes fixes for horizontal overflow and improves the usability of learning content on smaller displays.

6. Reliability, Safety, and Accessibility

This release also includes:

Fixes for homepage JavaScript functionality
An isolated, sandboxed code preview
Improved donation dialog accessibility
Stronger curriculum validation
Automated regression testing
Cross-browser smoke testing

The focus is not simply adding more features. It's also about making existing functionality more predictable and maintainable.

How Does LangSteps Work?

LangSteps is hosted publicly through GitHub Pages.

The frontend uses static web technologies with TypeScript compiled into JavaScript.

No login is required for public lessons, and supported learning progress is saved locally in the browser.

The repository also includes optional ASP.NET Core functionality that requires separate hosting; it is not part of the public GitHub Pages deployment.

Why I'm Building LangSteps

I believe high-quality programming education should be available without unnecessary financial or technical barriers.

LangSteps is an attempt to bring multiple programming technologies, practical learning resources, and helpful developer tools into one accessible platform.

It's still evolving, and community feedback is an important part of improving it.

Try LangSteps Today

Start learning: https://sanskarin.github.io/LangSteps/

Read the release notes: https://github.com/sanskarIN/LangSteps/releases/tag/v1.2.0

Explore the source: https://github.com/sanskarIN/LangSteps

If you're interested in programming education, TypeScript, accessibility, or open-source web development, I'd love to hear your feedback.

You can also support the project by starring the repository, reporting issues, suggesting improvements, or contributing code.

LangSteps — Learn programming, one step at a time.

Built with dedication to free and open-source education.

FrameTrellis v1.2.2: Faster H.264 Exports, Smarter Resolution Controls, and Improved Rendering Feedback

Sanskar — Wed, 21 Oct 2026 09:59:29 +0000

FrameTrellis v1.2.2: Faster H.264 Exports, Smarter Resolution Controls, and Improved Rendering Feedback

FrameTrellis v1.2.2 is now available as a stable release.

FrameTrellis is a free, open-source, local-first desktop video editor built with C++20, Qt 6/QML, MLT, and FFmpeg.

Earlier releases focused on core timeline workflows, title overlays, multi-clip editing, and stronger startup and packaging verification.

This release turns attention to another important part of video editing: the export experience.

Why focus on exports?

An editing workflow doesn't end when the timeline is finished.

Creators often need different kinds of output. Sometimes they want a full-resolution export. Other times, they need a smaller preview to review timing, transitions, and audio before producing a final version.

The objective of v1.2.2 is to make those choices easier while strengthening the checks around the generated MP4.

1. Quick H.264 export profiles

This release adds convenient export profiles for different situations.

Quick — Project Resolution

Exports at the project's resolution using the H.264 veryfast encoder preset with CRF 22.

Quick — Up to 1080p

Provides a speed-focused export capped at 1080p without automatically enlarging smaller projects.

Turbo — Up to 720p

Uses the H.264 superfast preset for rapid preview exports.

These are workflow presets, not promises of fixed export times. Performance depends on the project, effects, source media, hardware, and encoding settings.

2. Better control over upscaling

Unnecessary upscaling can increase the amount of encoding work without introducing new source detail.

FrameTrellis v1.2.2 adds an optional no-upscale checkbox to Export settings.

For developers using the separate render helper, the same policy is available through the --no-upscale command-line flag.

The existing fast draft preset has also been adjusted to avoid automatically magnifying smaller projects.

These changes help make the selected export resolution more predictable.

3. Live rendering performance information

The export interface now displays average rendering frames per second alongside progress and estimated remaining time.

This provides another useful signal when reviewing export performance.

Instead of looking only at the percentage completed, users can also see how quickly the renderer is processing frames.

4. Stronger output verification

Export correctness matters as much as speed.

Version 1.2.2 expands automated regression testing around:

Export preset policies.
Output dimensions and scaling decisions.
Retention of AAC audio.
Propagation of options to the helper process.

The release also strengthens dimension validation, rejecting invalid scaling requests before arithmetic is performed.

After rendering, FrameTrellis probes the completed MP4's dimensions before replacing any existing output file.

This reduces the risk of an unexpected output replacing a previously generated video.

5. Technical limitations worth understanding

FrameTrellis currently exports MP4 with H.264 video and AAC audio.

MLT parallel frame rendering remains disabled because of previously identified AAC corruption issues. Normal encoder threading remains in use.

The new export profiles do not implement stream-copy joining or guarantee GPU acceleration.

FrameTrellis is still an evolving desktop editor, and advanced capabilities including keyframes, proxy media, native editable title layers, and broader export format support remain future development work.

6. Compatibility and downloads

The existing .ftproj project format is unchanged.

Windows: The release provides an installer and a portable ZIP for Windows 10 version 1809 or later and Windows 11 on x64 hardware.

Linux: Users can build the application from source.

macOS: Official packages are not available yet.

Windows binaries are unsigned, so users should verify their SHA-256 checksums against those published with the release.

7. Built for local-first editing

FrameTrellis processes media locally without requiring an account or cloud-based editing service.

Its current technology stack includes:

C++20
Qt 6 and QML
MLT
FFmpeg
CMake

The project is open source under GPL-3.0-or-later.

Download FrameTrellis v1.2.2

Stable release:
https://github.com/sanskarIN/frametrellis/releases/tag/v1.2.2

Source code:
https://github.com/sanskarIN/frametrellis

Project website:
https://sanskarin.github.io/frametrellis/

What's next?

My goal is to keep improving FrameTrellis through practical features, automated testing, transparent documentation, and feedback from real users.

If you try v1.2.2, I'd especially appreciate feedback about the new export presets, resolution behavior, and progress information.

And if you're interested in building native desktop applications or multimedia software, contributions and technical discussions are welcome.

What should FrameTrellis prioritize next: proxy editing, subtitles, keyframe animation, or additional export formats?

Thanks for following the development of FrameTrellis!

— Sanskar

RepoDNA v1.4.2: Hardening the CLI, Archive Security, and Windows Packaging

Sanskar — Tue, 20 Oct 2026 13:29:52 +0000

RepoDNA v1.4.2: Hardening the CLI, Archive Security, and Windows Packaging

RepoDNA v1.4.2 is now available on GitHub!

This is a stability-focused release of my open-source, local-first repository intelligence and code archaeology platform.

Not every meaningful software update needs to introduce a new feature. Sometimes, the most important work happens in dependency management, input validation, command-line behavior, release automation, and regression testing.

That's the focus of RepoDNA v1.4.2.

What is RepoDNA?

RepoDNA helps developers understand software repositories through evidence-backed analysis.

It provides capabilities including:

Repository structure and language analysis
Architecture and dependency exploration
Git history and code archaeology
Code quality and security signals
Interactive reports, visualizations, and Project DNA cards
Local-first analysis through CLI, desktop, and web interfaces

RepoDNA is built primarily with Rust, TypeScript, React, and Tauri.

The goal is to make complex codebases easier to explore without requiring developers to send their source code to a remote service.

What's new in v1.4.2?

1. Improved Windows CLI startup behavior

Previously, launching the portable repodna CLI without arguments could return usage error code 2.

In v1.4.2, launching it without arguments displays the complete command reference and exits successfully.

Invalid options and subcommands still return the appropriate usage error.

This makes the command-line experience more consistent and may also help executable validation in packaging workflows.

2. Stronger archive-extraction security

Handling untrusted archives requires careful validation.

This release updates the core and desktop ZIP dependency lockfiles to version 9.0.4 to address published security advisories affecting the previous version.

Archive entry-name decoding now handles failures explicitly, rejecting malformed names before they reach path sanitization.

Portable ZIP validation also checks for unsafe entries, symbolic links, duplicate names, invalid executable paths, and archive integrity.

These protections reduce the risk of unsafe archive content being accepted during packaging and extraction.

3. Safer Windows packaging

RepoDNA offers both portable CLI builds and desktop installers.

In v1.4.2, WinGet manifest generation validates all four required Windows installer artifacts before writing the manifests.

Previously, a missing or invalid artifact could leave behind incomplete manifest files.

The updated workflow also improves checksum handling for larger installers and verifies executable paths and archive contents more carefully.

The result is stronger protection against incomplete or invalid release packages.

4. Expanded automated testing

Release engineering is not just about building files. It also involves checking what those files actually contain and how they behave.

RepoDNA v1.4.2 adds additional Windows portable ZIP smoke tests covering:

Portable executable layout
Binary architecture checks
CLI startup behavior
Help and version commands
Expected exit codes
Unsafe ZIP entries and missing executables
Empty or invalid installer artifacts

Windows x64 packages undergo execution-based verification in the supported CI environment.

ARM64 cross-compiled archives receive static validation, while native Windows-on-Arm execution testing remains a future verification step.

The release pipeline also verifies that required Windows MSI and setup EXE artifacts are nonempty.

5. Continued WinGet integration work

The release includes improvements to WinGet package manifest generation for the desktop and command-line distributions.

The intended package identifiers are:

Sanskar.RepoDNA
Sanskar.RepoDNA.CLI

WinGet catalog availability depends on Microsoft's separate review and indexing process. GitHub release publication does not automatically mean WinGet installation is available.

Download and try RepoDNA

You can download RepoDNA v1.4.2 for supported platforms from GitHub.

Release: https://github.com/sanskarIN/RepoDNA/releases/tag/v1.4.2

Repository: https://github.com/sanskarIN/RepoDNA

Web application: https://sanskarin.github.io/RepoDNA/

The web version lets you explore RepoDNA without installing the desktop application or command-line tool.

If you prefer command-line tools, you can also install the published npm package:

npm install --global @sanskarin/repodna

Then explore the available commands:

repodna --help

For analysis of a local repository:

repodna analyze .

What's next?

RepoDNA will continue evolving through improvements to analysis quality, platform compatibility, performance, documentation, usability, and release engineering.

Stability and security remain important parts of that development process.

Final thoughts

RepoDNA v1.4.2 is not primarily about adding more buttons or dashboards.

It's about strengthening the foundations that users rely on.

Safer archives, predictable CLI behavior, and more reliable package verification help make the overall developer experience more dependable.

If you work with unfamiliar repositories, maintain open-source projects, or enjoy developer tooling, I'd love for you to explore RepoDNA.

⭐ Star the repository, open an issue, or contribute on GitHub.

GitHub: https://github.com/sanskarIN/RepoDNA

Project website: https://sanskarin.github.io/RepoDNA/

Thanks for supporting open-source development!

LineLoom v1.2.0: A Native VS Code Control Center for Local Ollama Autocomplete

Sanskar — Tue, 20 Oct 2026 07:54:27 +0000

LineLoom v1.2.0: A Native VS Code Control Center for Local Ollama Autocomplete

LineLoom v1.2.0 is now available as a stable release on GitHub, with updated distribution through Visual Studio Marketplace and Open VSX.

This release focuses on making local AI-powered code completion easier to understand, configure, and control directly from Visual Studio Code.

What is LineLoom?

LineLoom is a free, MIT-licensed, open-source VS Code extension that brings AI-powered inline code suggestions to your editor using Ollama.

Instead of requiring an account with a hosted AI provider, LineLoom allows developers to use their own installed coding models.

The extension provides native inline suggestions, manual and automatic completion triggers, configurable model selection, privacy safeguards, and developer-controlled settings.

Local Ollama inference is the default. Explicitly configured and approved remote HTTPS endpoints are also supported.

What's new in v1.2.0?

1. A more informative native Control Center

One of the most noticeable improvements is the native LineLoom Activity Bar sidebar.

The Control Center brings together information and actions that developers previously needed to access through different commands.

It includes:

Completion and configuration status
Selected default and language-specific models
Active-editor eligibility information
Language controls
Workspace privacy and endpoint status
Shortcuts to diagnostics and connection checks

The sidebar is built around native VS Code UI components and does not initiate inference merely because the user opens it.

2. Clearer generation and connection states

LineLoom now provides more useful information about the completion engine.

The interface can distinguish between states such as ready, generating, disabled, unavailable, and error.

These distinctions matter because having a model name configured does not necessarily mean that Ollama is currently running or reachable.

The new status information aims to make configuration issues easier to identify.

3. Privacy-friendly performance diagnostics

v1.2.0 improves the extension's local session diagnostics.

The completion engine can report aggregated information, including:

Completion requests and suggestions
Cancellation counts
Cache hits
Typed-continuation reuse
Empty results and failures
Optional measured average latency

These statistics are held in memory rather than collected through a built-in telemetry service.

Average latency is shown only when performance diagnostics have been enabled and a valid sample has been collected.

4. Better Ollama error handling

The extension now provides clearer guidance for several categories of problems, including:

Unavailable Ollama servers
Missing models
Request timeouts
Authorization failures
Malformed or oversized responses

The goal is to help developers troubleshoot issues without exposing raw server error responses unnecessarily.

5. Safer model discovery

The model-selection workflow has also been hardened.

LineLoom validates returned model names, avoids duplicate entries, and rejects malformed or unreasonable model catalogs.

It also discards outdated model-discovery results when endpoint settings or remote approval change.

These improvements are particularly important for developers working with configurable inference endpoints.

Supported programming languages

LineLoom supports native inline completions for nine registered language IDs:

Python, JavaScript, TypeScript, Rust, Kotlin, Go, Java, C, and C++.

JSX and TSX are also handled through their corresponding JavaScript and TypeScript configurations.

Go, Java, C, and C++ remain experimental.

C# and Dart are not currently implemented in v1.2.0.

How to install LineLoom

Step 1: Install the extension

Visual Studio Marketplace:

https://marketplace.visualstudio.com/items?itemName=SanskarCodes.lineloom

Open VSX Registry:

https://open-vsx.org/extension/SanskarCodes/lineloom

Alternatively, download the stable VSIX from GitHub:

https://github.com/sanskarIN/LineLoom/releases/tag/v1.2.0

Step 2: Install Ollama

Download Ollama from:

https://ollama.com/download

Step 3: Install a compatible coding model

For example:

ollama pull qwen2.5-coder:1.5b

Model requirements and performance depend on the model and hardware.

Step 4: Configure LineLoom

Open a trusted project in VS Code.

Use the LineLoom Control Center or Quick Actions to choose the installed model and check your Ollama connection.

You can then trigger completions manually or use the configured automatic suggestion behavior.

Privacy and security

LineLoom is local-first, but it's important to understand what that means.

By default, completion context is sent to a locally configured Ollama endpoint.

The extension does not include built-in telemetry or automatically index an entire repository.

It also applies workspace trust checks, path exclusions, and additional inference permission checks.

If you explicitly configure and approve a remote HTTPS endpoint, relevant code context can be transmitted to that server.

For sensitive projects, review the privacy settings before enabling inference.

Testing and release status

v1.2.0 is a stable-channel GitHub release, not a pre-release.

Automated checks include cross-platform CI, mocked Ollama integration, package verification, and a VS Code CLI installation smoke test.

Some manual acceptance work remains open, including real-model completion quality, CPU/GPU latency, hands-on cross-platform editor checks, and accessibility verification.

The project tracks these remaining checks publicly.

What's next?

Development will continue to focus on making LineLoom more useful, reliable, and comfortable for everyday coding.

Community feedback will be especially valuable for understanding model behavior, responsiveness, editor integration, and configuration issues.

Try LineLoom

GitHub: https://github.com/sanskarIN/LineLoom

GitHub v1.2.0 release: https://github.com/sanskarIN/LineLoom/releases/tag/v1.2.0

VS Code Marketplace: https://marketplace.visualstudio.com/items?itemName=SanskarCodes.lineloom

Open VSX: https://open-vsx.org/extension/SanskarCodes/lineloom

Official website: https://sanskarin.github.io/LineLoom/

LineLoom is open source under the MIT License.

If you try it, consider sharing your experience, opening an issue, or contributing to the repository.

What feature would make local AI autocomplete more useful in your daily development workflow?

I Built LineLoom: A Local-First VS Code Autocomplete Extension — v1.0.0 Is Here

Sanskar — Mon, 19 Oct 2026 15:07:45 +0000

I Built LineLoom: A Local-First VS Code Autocomplete Extension — v1.0.0 Is Here

Write less. Build more. Stay in control.

Today, I'm excited to announce the first stable release of LineLoom v1.0.0, an open-source Visual Studio Code extension designed to provide inline code suggestions using locally configured Ollama models.

After progressing through multiple preview releases, LineLoom has reached an important milestone: it is now available through the Visual Studio Marketplace, Open VSX Registry, and GitHub Releases.

Why I started LineLoom

Coding assistants can be useful, but I wanted to explore an approach where developers have more control over the models they use and the context they share.

The goal behind LineLoom was to build a focused autocomplete extension rather than a full autonomous coding agent.

The design prioritizes native VS Code integration, configurable models, privacy-aware behavior, and an open-source implementation.

What LineLoom offers

1. Native inline code suggestions

LineLoom uses VS Code's inline completion system to offer suggestions directly in the editor.

It supports automatic and manual triggering, multiline suggestions, cancellation of outdated requests, and configurable generation settings.

2. Ollama integration

Developers can use a compatible Ollama model that they install and configure independently.

LineLoom also allows per-language model selection, making it possible to choose different installed models for different programming languages.

3. Nine language IDs

The initial stable release includes support for:

Python, JavaScript, TypeScript, Rust, and Kotlin.

It also registers experimental support for Go, Java, C, and C++.

4. Privacy-aware design

LineLoom operates locally by default and doesn't include built-in telemetry.

It uses bounded context from the active document rather than indexing an entire repository.

Trusted workspace checks, ignore rules, sensitive-file exclusions, and remote-endpoint approval controls help users manage which source context is sent to an inference endpoint.

When a user explicitly configures and approves an external HTTPS endpoint, the selected code context can leave the local machine. Local-first does not mean that all configurations remain offline.

5. More control over autocomplete

LineLoom includes Quick Actions for enabling and disabling suggestions, pausing automatic generation, selecting models, managing supported languages, checking the Ollama connection, and opening diagnostics.

It can also reuse the remainder of a recently generated suggestion when the user types a matching prefix under appropriate editor and privacy conditions.

How to install LineLoom

The easiest option is to open the Extensions panel in VS Code and search for LineLoom.

Verify that the publisher is SanskarCodes.

You can also install it using the VS Code CLI:

code --install-extension SanskarCodes.lineloom

Next, install and start Ollama independently and pull a compatible coding model. For example:

ollama pull qwen2.5-coder:1.5b

Open a trusted source-code workspace and use LineLoom: Quick Actions to select the model and check the connection.

Installation instructions are available on the official LineLoom website.

What does the stable release mean?

v1.0.0 is LineLoom's first stable distribution milestone.

The project includes automated TypeScript and lint checks, unit tests, packaging validation, and a VS Code extension-host integration test using a mocked Ollama server.

The GitHub release also includes a VSIX package and checksum.

However, these checks do not establish real-model completion quality, hardware performance, or full manual testing across Windows, Linux, and macOS.

Those areas remain open for additional testing and community feedback.

Where to get LineLoom

Visual Studio Marketplace:

https://marketplace.visualstudio.com/items?itemName=SanskarCodes.lineloom

Open VSX Registry:

https://open-vsx.org/extension/SanskarCodes/lineloom

GitHub repository:

https://github.com/sanskarIN/LineLoom

Stable release:

https://github.com/sanskarIN/LineLoom/releases/tag/v1.0.0

Official website:

https://sanskarin.github.io/LineLoom/

What's next?

I plan to continue improving completion behavior, documentation, testing, model compatibility, and developer experience.

Real-world bug reports and compatibility feedback are especially valuable as the project moves forward.

LineLoom is free and MIT-licensed. Developers are welcome to inspect the source, report issues, suggest improvements, and contribute.

If you're interested in local-first developer tools, I'd love to hear what you think.

Your model. Your editor. Your control.

Thanks for checking out LineLoom! 🚀

FrameTrellis v1.2.1: Startup Diagnostics, Windows Verification, and Release Reliability

Sanskar — Sun, 18 Oct 2026 05:41:08 +0000

FrameTrellis v1.2.1: Startup Diagnostics, Windows Verification, and Release Reliability

FrameTrellis v1.2.1 is now available as a stable maintenance update to my local-first, open-source desktop video editor built with C++20, Qt 6/QML, MLT and FFmpeg.

Unlike v1.2.0, which focused on batch timeline-editing improvements, v1.2.1 strengthens the engineering behind startup, packaging and validation.

1. More useful startup diagnostics

The editor now records additional checkpoints during application startup, QML window creation, event-loop shutdown and final cleanup.

These logs make it easier to investigate where something went wrong during the startup lifecycle.

Another improvement concerns initialization failures. When QML window creation fails, the application now follows its normal cleanup sequence for controllers, background worker tasks and the MLT runtime.

2. Stricter Windows package verification

The Windows packaging workflow now retains more diagnostic information, including standard output, standard error and available crash logs.

Module inspection has also become stricter. Invalid DLL paths, including misleading directory-prefix matches and traversal outside allowed locations, are rejected.

On Windows 11 ARM64 CI runners, the x64 application is checked under emulation through two independent launches. Both must succeed and produce fresh screenshots.

This prevents a successful second run from hiding an earlier failure.

3. Expanded regression testing

This release adds a dedicated Windows PowerShell regression suite for module-path validation.

Pre-release validation also included Linux GCC builds, sanitizer testing, Windows MSYS2 compilation, GUI tests and package verification workflows.

The final release process independently rebuilds and checks the version-stamped Windows packages.

4. An important limitation

An intermittent startup problem involving Qt6Core.dll was previously observed on a Windows 11 ARM64 CI runner.

Later verification runs passed, but the underlying cause remains undetermined.

Version 1.2.1 improves diagnostics and failure detection. It does not claim that the original issue has been definitively fixed.

5. Availability and compatibility

The existing .ftproj project format remains unchanged.

Windows 10 (1809 or later) and Windows 11 x64 users can download an installer or portable ZIP. Linux users can build from source.

Windows packages are unsigned, so users should verify their SHA-256 checksums.

WinGet integration is not part of this release.

Get FrameTrellis

GitHub release:
https://github.com/sanskarIN/frametrellis/releases/tag/v1.2.1

Source repository:
https://github.com/sanskarIN/frametrellis

Website:
https://sanskarin.github.io/frametrellis/

FrameTrellis continues to evolve through open development, testing and community feedback.

If you're interested in C++, Qt, FFmpeg or desktop application engineering, I'd welcome your thoughts on startup diagnostics and release verification.

I Built SpeedPulse: An Open-Source Internet Speed Tester with ASP.NET Core 10 and TypeScript

Sanskar — Sat, 17 Oct 2026 15:10:55 +0000

I Built SpeedPulse: An Open-Source Internet Speed Tester with ASP.NET Core 10 and TypeScript

After working on its testing interface, diagnostics, backend, and release pipeline, I'm excited to introduce SpeedPulse v1.0.0, the first stable release of my open-source internet speed testing project.

SpeedPulse is designed to provide an approachable way to measure connection performance while giving developers additional tools to explore network behavior.

What is SpeedPulse?

SpeedPulse is a browser-based internet speed testing application.

It provides measurements for download and upload throughput, HTTP latency, approximate jitter, and failed HTTP probes, alongside interactive charts and results history.

You can try it directly on GitHub Pages:

https://sanskarin.github.io/SpeedPulse/

Features in v1.0.0

1. Connection speed testing

SpeedPulse provides:

Download and upload speed measurements
HTTP latency and approximate jitter
Failed HTTP probe monitoring
Live progress and visualizations

These are browser-level estimates, rather than laboratory-grade or packet-level network measurements.

2. Interactive dashboard

The application includes visualizations for exploring connection performance, along with locally stored results history.

Users can export results as CSV and share their measurements.

3. Developer Labs

One part of SpeedPulse that I'm particularly interested in developing further is Developer Labs.

It brings together diagnostic utilities including backend health checks, HTTP probes, browser capability reporting, diagnostic exports, and explicitly labeled simulations.

The goal is to make network behavior easier to inspect and understand.

4. Optional ASP.NET Core 10 backend

SpeedPulse supports two deployment approaches.

Hosted web version

The GitHub Pages deployment uses a static frontend and public Cloudflare testing endpoints.

Self-hosted version

The optional ASP.NET Core 10 backend provides local HTTP testing endpoints, health and configuration APIs, bounded transfers, and request limiting.

An important distinction: tests against a server running on the same computer measure the local loopback path, not your internet service provider's speed.

Technology stack

The project brings together:

C# and ASP.NET Core 10
TypeScript and JavaScript
HTML and CSS
Chart.js
Node.js build tooling
GitHub Actions
GitHub Pages

Improving measurement reliability

An important part of preparing v1.0.0 was improving how the application handles partial test failures.

Previously, an upload failure could interrupt the experience even after earlier measurements had succeeded.

The stable release now preserves completed measurements and marks an unavailable upload result appropriately instead of treating it as zero.

I also corrected live chart behavior and added regression coverage for these scenarios.

Download SpeedPulse v1.0.0

The release includes a static web archive and self-hosted ASP.NET Core packages for Windows x64, Linux x64, and Apple Silicon macOS.

GitHub release:

https://github.com/sanskarIN/SpeedPulse/releases/tag/v1.0.0

Source code:

https://github.com/sanskarIN/SpeedPulse

Live application:

https://sanskarin.github.io/SpeedPulse/

What's next?

Future development can continue improving measurement reliability, developer diagnostics, usability, and testing across different environments.

Since the project is open source under the MIT License, contributions and technical feedback are welcome.

If you explore SpeedPulse, I'd particularly love to hear about browser compatibility, unexpected measurement behavior, or ideas for making the diagnostics more useful.

Thanks for checking out SpeedPulse!

Built by Sanskar

GitHub: https://github.com/sanskarIN

Website: https://sanskarin.github.io