Basic Windows Antivirus Development

@kamran2012

Good to see this project, I will deliver the scan engine — on-demand and full-disk — with a real-time protection service using a Windows minifilter driver to intercept file I/O at the kernel level, plus a native GUI exposing quarantine, delete, and block actions for each detection. For the architecture, I will separate the signature store into a flat-file definition format that hot-reloads without restarting the service. Pairing that with a heuristic module that scores PE header anomalies and API call entropy will keep detection strong while minimizing false positives — especially important when new definitions are added frequently. EICAR and live malware samples will validate both paths during the demo. Looking forward to your response. Best regards, Kamran

@vishal1145

Your real-time protection layer will fail if you hook file operations without implementing a minifilter driver - user-mode hooks get bypassed by kernel-level malware and won't intercept system processes. This isn't just a performance issue; it's a fundamental security gap that makes the antivirus ineffective against rootkits. To ensure we're building this correctly, I need clarity on two things: Are you planning to sign a kernel-mode driver (which requires an EV certificate and Microsoft attestation), or should I architect a hybrid approach using filesystem filter drivers with user-mode fallbacks? Second, what's your target detection rate - are we aiming for 95% coverage against known threats, or do you need behavioral analysis that catches zero-days? Here's the architectural approach: - C++ WITH WINDOWS FILTER MANAGER: Build a minifilter driver that registers IRP_MJ_CREATE callbacks to intercept file opens at the kernel level, ensuring malware can't bypass scanning by operating below user mode. - SIGNATURE ENGINE WITH YARA INTEGRATION: Implement a pattern-matching system using memory-mapped files and Boyer-Moore algorithm to scan 1GB files in under 10 seconds while keeping RAM usage below 200MB. - HEURISTIC ANALYSIS: Deploy entropy calculation and PE header validation to flag packed executables and suspicious API imports without relying solely on signature databases. - QUARANTINE WITH ENCRYPTION: Store flagged files in AES-256 encrypted containers with metadata tracking to prevent accidental execution while allowing restoration if needed. - EVENT LOGGING: Write scan results and threat actions to Windows Event Log with structured XML for SIEM integration and compliance auditing. I've built kernel-mode security software for two endpoint protection vendors that passed AMTSO certification tests. I don't take on projects where driver signing and Windows Hardware Quality Labs requirements aren't clearly defined upfront. Let's schedule a 20-minute call to walk through the minifilter architecture and discuss your code-signing infrastructure before we commit to a build timeline.

@letswork92

Creating a lightweight antivirus tailored for Windows demands expertise in real-time file operations and threat detection. Your challenge lies in developing a seamless user experience while ensuring efficient performance during scans and real-time protection. With 12+ years of experience in software development, I propose utilizing C++ or C# with Windows APIs to achieve optimal performance and native execution. I'll implement on-demand and full-disk scanning features, along with a robust service that monitors file activities. Incorporating signature and heuristic detection methods will allow us to address both viruses and malware effectively, ensuring low false positives. The deliverables will include an installer, real-time protection service, scan engine with logging capabilities, and user-friendly UI for response actions. I prioritize clean, documented source code to facilitate future updates. To tailor the solution perfectly, could you specify any particular design preferences for the UI or additional features you envision?

@techsty2014

Hey, I will build your lightweight Windows AV: kernel-mode File System Minifilter (FSMini) for real-time file-op interception, user-mode service for signature matching and quarantine, and a WPF GUI with quarantine/delete/block actions, scan logs, and start/stop control. YARA rules for the signature/heuristic engine: adding definitions = dropping in a .yar file, not recompiling. PE header heuristics + reputation cache keep false positives low. Signing: prototype works in test-signing mode; production kernel driver needs EV cert + WHQL submission via Microsoft Partner Center. Questions: 1) Target Windows versions: 10/11 only, or 7/8 too? 2) Production: WHQL signed for unattended install, or test-signing acceptable? 3) Initial signature list format: YARA, ClamAV, or raw hashes? Ready to start whenever you are. Faizan

@KarthikTechCon

Hi, I’m Karthik from Resonite Technologies with 15+ yrs in **Windows systems, security tools, and performance-critical apps**. I can build a **lightweight native Windows antivirus prototype** with real-time protection and extensible detection. **Proposed Architecture** • Core: **C++ (Windows APIs)** for low-level file I/O + filter drivers (or C# + native hooks if preferred) • Service: Background **real-time scanning service** (start/stop controllable) • Engine: Signature-based + heuristic detection (modular rules engine) • Storage: Optimized signature DB with fast lookup (hash + pattern matching) **Core Features** ✔ On-demand & full-disk scans (multi-threaded, fast) ✔ Real-time interception of file operations ✔ Threat handling: quarantine, delete, block (clear UI actions) ✔ Logging system (readable audit trail) ✔ Easy signature updates (pluggable definitions) **UI** Lightweight WinForms/WPF GUI for scan control, results, and actions **Deliverables** ✔ Installer + signed executable ✔ Real-time protection service ✔ Scan engine + GUI ✔ Clean, documented source code + build guide **Acceptance** EICAR detection, action handling, and logs fully demonstrated. **Timeline** Prototype: 4–5 weeks **Experience** Built system-level tools, monitoring agents, and secure Windows applications. Happy to discuss detection strategy and architecture. Best regards, Karthik Resonite Technologies

@NEHABHAT92

With nearly a decade's worth of experience in mobile and web development, my team and I are ready to help you tackle your Windows antivirus project. Our skillset in various programming languages such as C++, C#, and Java combined with our proficiency in wielding Windows APIs for native execution make us a perfect fit for your needs. We understand the necessities required to counteract the rising threat of viruses and malware, and we pledge to deliver your solution efficiently. There are several aspects of this project that align precisely with our past experiences. We have successfully built numerous real-time security services that demonstrate strong file interception capabilities similar to what you require. Additionally, defining signature and heuristic detections for malicious software is a task that we've accomplished effectively in the past. With this project we'll leverage our understanding to promise minimal false positives while keeping new definitions easily updatable.

@alluankit01

Hi, I can build a native Windows antivirus prototype with on-demand scanning, full-disk scanning, real-time protection control, quarantine/delete/block actions, and clear event logging. I understand the critical part is real-time scanning, not just a simple file scanner. My approach would be to build a clean scan engine with signature matching, basic heuristic checks, EICAR validation, quarantine handling, and a lightweight Windows GUI/service. For real-time protection, I’ll use Windows-native file monitoring/hooks suitable for the prototype stage, and clearly document what requires a signed kernel minifilter driver for production-level interception. The architecture will keep signatures easy to update, logs readable, and false positives controlled. I can deliver the installer, executable/service, documented source code, build steps, and a live demo detecting seeded EICAR files with all three response actions working. Please share your initial signature list and whether you expect prototype-level real-time monitoring or production-grade kernel driver protection. Best regards Ankit

@arshkumar213

I will deliver a native, "0→1" Windows antivirus prototype using **C++** and the **Windows API**. Leveraging my background in high-performance engineering, I’ll architect a kernel-mode or user-mode service for real-time interception with a "pixel-perfect" UI. * **Engine:** Fast signature/heuristic scanning for viruses and malware. * **Real-time:** Native file-system hooks with Quarantine/Delete/Block actions. * **Security:** Detects EICAR files with zero false positives. Ready to demo. C++ or C# for the GUI?

@norton300

Hi, I can develop this lightweight antivirus prototype using C++ and the Windows API. C++ is the industry standard for this task because it offers the low-level memory control needed for fast disk scanning and the performance required for real-time file interception without slowing down the OS. My Technical Roadmap: Real-Time Protection: I will implement a Windows Minifilter Driver (or use the Windows FltMgr framework). Това позволява на софтуера да прихваща операции като IRP_MJ_CREATE (отваряне на файл) и да сканира съдържанието, преди системата да разреши достъп. Scan Engine: I’ll use a multi-threaded approach for full-disk scans, utilizing Memory-Mapped Files for maximum speed. Detection Logic: I will build a modular engine that supports Aho-Corasick pattern matching for fast signature detection and a basic Heuristic analyzer to flag suspicious entry points or unusual PE headers. Quarantine System: I’ll implement a secure, encrypted storage vault for threats, preventing accidental execution after detection. GUI: A clean, native Win32 or WPF (C#) interface that communicates with the C++ backend service via IPC (Named Pipes). Deliverables: Signed Executable & Installer: A professional setup package. Core Service: Background real-time protection with a tray-based control. Source Code: Fully documented C++/C# code with a clear build pipeline. Timeline: 4–6 weeks. Let’s discuss the specific signature format you plan to provide. Best Regards

@saiqasheikhwork5

Hi there! I'm Saiqa, a seasoned Senior Full Stack Developer with a speciality in secure and high-performance software design and implementation. Although my core services span Mobile App and Web Development, what better challenge than to build an antivirus? I am confident in my ability to meet your project's demanding requirements. With my profound understanding of system architecture, I'll propose the most suitable tech stack(C++, C#, or Rust) that will both facilitate faster scans on Windows machines, and efficient integration of signature/heuristic detection of viruses and malware, keeping false positives low. Moreover, my knowledge of backend & database architecture will ensure your need for a solid quarantine/deletion/blockage UI is met, displaying the results as they should be - clear and informative. I approach every project holistically, combining technical expertise with an understanding that usability drives adoption. Each solution I build is well-documented which ensures seamless, maintenance and future-proofing. Lastly, it's important we're completely aligned. From initial idea validation to delivery and long-term post-deployment maintenance - we'll be a true partnership; you have my full support. Choose me for this project and together we'll create an intuitive and secure product that outpaces threats on Windows machines in real-time. Let's get started!

@kausarafridi07

With over a decade of experience in software development, my team at MTAI Software Labs and I are well-equipped to handle the complexities of your Windows antivirus project. Our proficiency in Windows APIs combined with languages like C++, C#, or Rust is precisely what you need for a native, efficient solution. We understand the need for speed, scalability, and security in antivirus software and assure you that our approach will align with those goals. Furthermore, we've extensive knowledge in building powerful scanning engines with low false positives, which will be instrumental in delivering on-demand and full-disk scans effectively. Our core expertise also includes developing real-time protection services that seamlessly integrate into the OS and handle file operations with utmost efficiency. Lastly, we appreciate the importance of reliable code, thorough documentation, and precise logging for security software. We guarantee not only a well-structured solution but also a user-friendly interface with clear options to handle threats effectively. By choosing us, you can not only expect an effective and performant Windows antivirus but also ongoing support and maintenance essential for a product that remains competent in an ever-evolving digital landscape. I believe our focused approach to business-driven solutions perfectly matches your requirements and look forward to creating something impactful together!

@techotd

Hello, I can build your lightweight Windows antivirus from concept to a working MVP with a clean, scalable architecture designed for real-time protection and fast scanning performance. I specialize in C++ / C# Windows systems development and have experience working with low-level Windows APIs, service-based applications, and performance-critical security tools. What I will deliver: • Fast on-demand + full-disk scan engine (multi-threaded for speed) • Real-time file monitoring service using Windows system APIs • Signature-based + heuristic detection engine (modular for easy updates) • Threat response system: Quarantine / Delete / Block with clear UI integration • Clean Windows-native application (no Electron/Java) • Structured logging system + EICAR test compatibility • Installer + production-ready build • Well-documented, modular source code for future scaling Architecture Approach: I will use a hybrid C# + C++ design: C++ for scan engine (performance + detection logic) C# (WPF) for UI + service orchestration Windows Service for real-time protection layer This ensures speed, stability, and maintainability while keeping false positives low and updates easy. I will also design the system so new signatures can be added without touching core logic. If required, I can also extend this into kernel-level protection or cloud-based signature updates in later phases.

@bondoc0526

꧁ ༺ Dear client ༻ ꧂ I can build a Windows antivirus that watches your files in time. It will scan your computer quickly and thoroughly. It will also detect threats using known patterns and smart guesses. If it finds something you can choose to quarantine, delete or block it. I will make sure the antivirus is easy to update so it can stay ahead of threats. I will also make sure it doesn't make mistakes and flag good files bad. I will set up logging and control so it can protect your computer properly. I have experience building security tools for Windows. I know how to write stable code. I think I can do a job, on this project. Lets talk about how to do it and make a plan before we start.

@khrystynad4

Hello, I can help build a Windows-native lightweight antivirus prototype with on-demand scans, full-disk scanning, real-time protection, signature/heuristic detection, quarantine/delete/block actions, logging, and a basic GUI. This project fits my background in C/C++, Python, Windows/system-level software, backend logic, debugging, validation, and reliability-focused engineering. My proposed approach: 1. Design the architecture: scan engine, definitions format, real-time protection service, quarantine manager, logging, and GUI. 2. Implement signature scanning for the provided definitions, including EICAR validation. 3. Add basic heuristic checks with conservative rules to reduce false positives. 4. Build on-demand and full-disk scanning with progress reporting and readable logs. 5. Implement a Windows service for real-time monitoring of file operations, with start/stop control. 6. Add clear user actions: quarantine, delete, or block. 7. Package the prototype with installer/build instructions and clean documented source code. For the stack, I would recommend C++ or C# with Windows APIs depending on the required depth of real-time interception. I will keep the definitions easy to extend and the code modular so future threat classes, UI improvements, and update mechanisms can be added later.

@Anika1802

Hey! As an experienced full-stack developer with expertise in Java and C++, I believe I would be the perfect fit for your Windows antivirus project. Not only do I possess the technical skills required for this task, but I also maintain a strong focus on performance optimization and application security - two characteristics critical to an antivirus software. In my five years of professional experience, I have designed and implemented numerous high-performing systems, SaaS platforms, and even spearheaded the development of AI-powered applications. This diverse background has equipped me with a unique perspective and a thorough understanding of different development environments and the importance of clean codebase - all paramount for your lightweight native Windows antivirus. Additionally, being well-versed in API development and third-party integrations, I can easily accommodate your needs for adding new virus definitions without jeopardizing the system's efficiency or inundating it with false positives. My capabilities extend beyond coding walls as well—I provide comprehensive documentation alongside code, making it simple for next-in-line developers to maintain and upgrade the software effortlessly.

@shokoufeh1994

Antivirus development is an area I find genuinely interesting — it sits at the intersection of OS internals, file-system monitoring, and signature-based detection, all in C#. Here is what I would build: a Windows service using FileSystemWatcher to monitor directories in real time, a signature scanner that hashes files (SHA-256) against an updateable local database, a quarantine mechanism that moves flagged files to an ACL-restricted folder, and a lightweight WPF tray icon for status and manual scans. I have solid experience with C# Windows services, P/Invoke for Windows API calls, and WMI for process and registry monitoring. I also know how to hook into Windows Defender's AMSI interface if you want system-level integration rather than building entirely from scratch. A couple of quick questions: Should the signature database be self-maintained or auto-updated via a channel? Do you need scheduled full-disk scans in addition to real-time protection? I can start immediately and deliver a working proof-of-concept within the first 3-4 days.

@karthikresonite

Hi, Resonite Technologies here — we have strong experience in **Windows system-level development, security tools, and real-time file monitoring**. We can build your antivirus prototype from concept to working demo. ✔ Proposed Architecture: • Native **C++ / C# (.NET) with Windows APIs** • **File system filter / watcher** for real-time interception • Modular **scan engine (signature + heuristic)** • Lightweight **Windows service** + simple GUI ✔ Key Features: • Fast **on-demand & full-disk scans** (multi-threaded) • Real-time protection (monitor file create/read/write) • Signature-based detection + basic heuristic rules • Actions: **Quarantine / Delete / Block** with clear UI • Logging system (scan results, actions, timestamps) • Easy signature updates (config-driven definitions) ✔ Deliverables: • Installer + signed executable • Real-time protection service (start/stop control) • Scan engine + GUI • Clean, documented source code + build guide ✔ Our Experience: • Built low-level Windows tools, monitoring services & security utilities • Strong in C++, .NET, system APIs, and performance optimization ✔ Timeline: 2–3 weeks for working prototype (EICAR detection demo ready) We’ll ensure **low false positives, fast scans, and stable real-time protection**. Ready to start immediately. — Karthik Resonite Technologies

@igorc50

With a strong background in computer programming and a focus on building efficient, practical solutions, I believe I am the ideal candidate for this project. Not only have I worked extensively with C++, C#, and Windows APIs, but I also have a deep understanding of virus and malware detection strategies - both signature-based and heuristic. My expertise in C/C# programming languages coupled with my understanding of Information systems will ensure a lightweight antivirus that performs fully well on modern Windows machines. In addition, my experience in creating clean, documented source codes will be reflected in my delivery of a well-commented and easy-to-understand codebase. What sets me apart from other candidates is not just my technical proficiency but also my clear understanding of user interface design. I understand the importance of user experience and ensuring that your clients can easily detect threats and take appropriate measures. This will be visible in the way I design the UI to clearly reflect all three response options: quarantine, delete, or block.