Startup Program Manager

Every program that adds itself to startup makes your boot a little slower, and the built-in tools show you a flat list with no guidance about what is safe to touch. This project builds a startup program manager that treats boot as a measurable system: it inventories auto-start entries across the standard launch points (registry Run keys, Startup folders, scheduled tasks, services), scores each entry's impact on boot time from its measured load profile, and lets the user disable, delay, or re-enable items with one-click undo. A boot timeline visualizes the sequence — what loads when, what waits on what — and a simulator shows the projected boot time as entries are toggled. Safety is the core design constraint: entries are classified by risk, critical system components are locked against disabling, and every change is reversible. The demo runs against a realistic dataset of 40+ Windows-style startup entries so every feature is exercisable.

1. On launch, the manager scans the standard auto-start locations and builds the inventory with metadata per entry.
2. Each entry's impact score is computed from its load profile: startup CPU/disk cost plus its position in the dependency chain.
3. The boot timeline lays entries on a time axis, honoring dependencies (services before dependents, delayed items shifted right).
4. Toggling an entry off removes its bar from the timeline; delaying shifts it; the simulator recomputes total boot time instantly.
5. Risk rules lock critical system entries against disabling and warn on caution-level ones before applying.
6. Every change is recorded in an action history with one-click undo restoring the previous state.
7. Export produces a before/after boot report summarizing disabled, delayed and kept entries with projected savings.

Tech stack:

• JavaScript (ES6+)
• Boot sequence model
• Impact scoring engine
• Timeline visualization (canvas)
• Single-file web app
• Realistic 40+ entry dataset

• [Complete startup inventory] 40+ realistic entries across registry Run keys, Startup folders, scheduled tasks and services, each with publisher, launch point and command line.
• [Boot impact scoring] Each entry gets an impact score from its load profile (CPU, disk, delay), so users see exactly what costs boot seconds.
• [Safe enable/disable with undo] Toggle entries freely; critical system items are locked, and every change can be reverted in one click.
• [Delayed start] Defer non-urgent apps by a configurable delay so the desktop becomes usable faster.
• [Boot timeline visualization] A timeline shows the boot sequence with per-entry bars, dependencies and the critical path.
• [Boot time simulator] Toggle or delay entries and watch the projected total boot time update live.
• [Risk classification] Entries are labeled safe, caution or critical based on publisher and launch point, guiding non-expert users.

• Single-file startup manager app (working demo)
• Boot model and impact-scoring source code
• 40+ entry realistic dataset
• User guide: reading the timeline, safe toggling
• Project report PDF (OS boot process, autostart mechanisms, scoring model)
• PPT presentation for final review
• Viva Q&A preparation document

• The demo manages a realistic simulated entry set; the shipped Windows build hooks the real registry/task APIs (documented in the report).
• Impact scores are computed from modeled load profiles, not measured traces on the user's machine — stated as estimates throughout the UI.
• Delaying startup items improves time-to-usable-desktop, not total background load.
• Disabling the wrong third-party entry can break that app's features; the undo history is the safety net, not a guarantee.
• macOS/Linux autostart mechanisms (LaunchAgents, systemd) are future scope.
• The simulator assumes sequential-with-overlap loading; heavily parallel SSD boots will differ.