Windows 11: Autostart-Programme prüfen, Fehler erkennen und beheben

Wenn Dein Windows-Computer nach dem Einschalten lange braucht oder nach der Anmeldung nur langsam reagiert, können zu viele automatisch gestartete Programme eine Ursache sein. Häufig laufen im Hintergrund Anwendungen, die Du gar nicht bei jedem Start benötigst.

Doch nicht jeder Autostart ist überflüssig. Manche Programme erfüllen wichtige Aufgaben. Andere wurden bewusst deaktiviert oder hinterlassen nach einer Deinstallation lediglich harmlose Restinformationen.

In diesem Ratgeber erfährst Du, wie Du Autostart-Programme unter Windows 11 und Windows 10 überprüfst, unnötige Programme deaktivierst und mögliche Fehler sicher erkennst und behebst.

Außerdem wird erklärt, warum manche Autostart-Einträge nach der Deinstallation eines Programms erhalten bleiben und was es mit den sogenannten verwaisten Autostart-Statusinformationen auf sich hat.

Für fortgeschrittene Anwender gibt es am Ende zusätzliche PowerShell-Anleitungen zur Diagnose, Sicherung und gezielten Bereinigung von Registry-Einträgen.

Was sind Autostart-Programme?

Autostart-Programme sind Anwendungen oder Programmteile, die Windows automatisch ausführt, ohne dass Du sie selbst öffnen musst.

Häufig geschieht das direkt nach der Anmeldung an Deinem Benutzerkonto.

Beispiele dafür sind:

• Cloud-Programme, die Dateien automatisch synchronisieren.
• Messenger, die Dich über neue Nachrichten informieren.
• Passwortmanager oder andere regelmäßig benötigte Hilfsprogramme.
• Geräteprogramme, die zusätzliche Funktionen für Maus, Tastatur oder andere Hardware bereitstellen.
• Programme, die im Hintergrund auf bestimmte Aufgaben warten.

Diese automatischen Starts sind grundsätzlich sinnvoll. Allerdings benötigen die Programme dafür auch Systemressourcen.

Was ist der Unterschied zwischen Windows-Start und Benutzeranmeldung?

Wenn Du Deinen Computer einschaltest, startet Windows zunächst das Betriebssystem.

Dabei werden unter anderem notwendige Treiber und Systemdienste geladen.

Erst anschließend meldest Du Dich mit Deinem Benutzerkonto an. Viele gewöhnliche Autostart-Programme werden erst nach dieser Anmeldung ausgeführt.

Deshalb ist eine wichtige Unterscheidung notwendig:

Nicht jedes Programm, das automatisch mit Windows startet, erscheint auch in der Autostart-Liste des Task-Managers.

Windows-Dienste, geplante Aufgaben und andere automatische Startmechanismen können unabhängig davon arbeiten.

Welche Autostart-Programme sind notwendig?

Grundsätzlich lassen sich Autostart-Programme in drei Gruppen einteilen.

Kategorie	Beispiele	Empfehlung
Wichtig	Benötigte Sicherheitssoftware, Eingabehilfen, wichtige Gerätefunktionen	Normalerweise aktiviert lassen
Sinnvoll	Cloud-Synchronisierung, Passwortmanager, häufig benötigte Kommunikationsprogramme	Je nach Nutzung entscheiden
Optional	Selten verwendete Messenger, Spiele-Launcher, zusätzliche Programmstarter	Häufig deaktivierbar

Welche Programme Du tatsächlich benötigst, hängt davon ab, wie Du Deinen Computer verwendest.

Wenn Du beispielsweise täglich Dateien über OneDrive synchronisierst, kann dessen automatischer Start sinnvoll sein.

Verwendest Du einen Messenger dagegen nur gelegentlich, benötigst Du ihn möglicherweise nicht direkt nach jeder Anmeldung.

Wie beeinflussen Autostarts die Windows-Leistung?

Wenn Programme automatisch gestartet werden, benötigen sie Ressourcen Deines Computers.

Dazu gehören insbesondere:

• Prozessorleistung (CPU): Der Prozessor muss zusätzliche Aufgaben ausführen.
• Arbeitsspeicher (RAM): Programme belegen einen Teil des verfügbaren Speichers.
• SSD oder Festplatte: Beim Start werden Programmdateien geladen.
• Netzwerk: Manche Programme stellen unmittelbar eine Internetverbindung her.

Wenn mehrere Anwendungen gleichzeitig starten, kann sich die Anmeldung verzögern.

Einige Programme laufen anschließend dauerhaft im Hintergrund weiter.

Aber: Nicht jedes Autostart-Programm verlangsamt Deinen Computer spürbar.

Und auch eine möglichst leere Autostart-Liste ist kein sinnvolles Ziel.

Wenn Dein Computer grundsätzlich langsam reagiert, findest Du weitere mögliche Ursachen in unserem Ratgeber „Windows-Computer wieder etwas schneller machen“.

Autostart-Programme unter Windows 11 anzeigen und verwalten

Windows bietet mehrere Möglichkeiten, automatische Programmstarts zu überprüfen.

Für die meisten Nutzer reichen der Task-Manager und die Windows-Einstellungen vollkommen aus.

Andere Methoden ermöglichen eine genauere Untersuchung, erfordern aber teilweise etwas mehr technisches Wissen.

1. Autostart-Programme im Task-Manager anzeigen

Öffne den Task-Manager mit:

[Strg] + [Umschalt] + [Esc]

Wähle anschließend „Autostart von Apps“.

Hier werden die von Windows erkannten Autostart-Anwendungen angezeigt.

Je nach Programm findest Du folgende Informationen:

Information	Bedeutung
Name	Bezeichnung des Programms
Herausgeber	Hersteller beziehungsweise Anbieter
Status	Aktiviert oder deaktiviert
Startauswirkung	Geschätzte Belastung während des Starts

Die Startauswirkung kann beispielsweise als „Hoch“, „Mittel“ oder „Niedrig“ angegeben werden.

Manchmal erscheint auch „Nicht gemessen“.

Das bedeutet lediglich, dass Windows noch keine ausreichenden Messwerte besitzt.

Eine hohe Startauswirkung ist kein Programmfehler.

Windows weist damit nur darauf hin, dass das betreffende Programm beim Start vergleichsweise viele Ressourcen benötigt.

Wenn Du nicht weißt, zu welcher Anwendung ein Eintrag gehört, kannst Du bei vielen Einträgen über einen Rechtsklick den Dateipfad öffnen.

Prüfe die Herkunft eines Programms lieber zuerst, bevor Du etwas veränderst.

2. Autostarts über die Windows-Einstellungen verwalten

Eine weitere einfache Möglichkeit findest Du in den Windows-Einstellungen.

Öffne:

Einstellungen → Apps → Autostart

Hier kannst Du verfügbare Autostart-Programme über einen Schalter ein- oder ausschalten.

Du kannst die Seite auch direkt öffnen:

1. Drücke die Tastenkombination [Windows] + [R].
2. Gib folgenden Befehl ein:

ms-settings:startupapps

3. Bestätige mit [Enter].

Windows öffnet die entsprechende Einstellungsseite.

Vorteil: Die Bedienung ist einfach und Änderungen lassen sich jederzeit rückgängig machen.

Nachteil: Auch diese Übersicht erfasst nicht sämtliche möglichen automatischen Startmechanismen.

3. Autostartordner von Windows öffnen

Windows verwendet zusätzlich klassische Autostartordner.

Darin können sich Verknüpfungen zu Programmen befinden, die bei einer Anmeldung automatisch gestartet werden sollen.

Es gibt zwei wichtige Ordner.

Persönlicher Autostartordner

Dieser Ordner gilt für Dein Benutzerkonto.

Drücke [Windows] + [R] und gib ein:

shell:startup

Gemeinsamer Autostartordner

Dieser Ordner gilt für alle Benutzer des Computers.

Öffne ihn mit:

shell:common startup

In diesen Ordnern kannst Du vorhandene Programmverknüpfungen überprüfen.

Wenn Du eine Verknüpfung nicht mehr benötigst, kannst Du sie entfernen.

Achtung: Entferne dabei nur die betreffende Verknüpfung und nicht versehentlich die eigentliche Programmdatei. Für Änderungen am gemeinsamen Autostartordner können Administratorrechte notwendig sein.

4. Autostart-Programme in der Windows-Registrierung finden

Einige Programme speichern ihre automatischen Startbefehle in der Windows-Registrierung.

Diese wird auch Registry genannt.

Die Registry ist eine zentrale Datenbank, in der Windows und installierte Programme zahlreiche Einstellungen speichern.

Du kannst sie mit dem Registrierungseditor öffnen.

Drücke:

[Windows] + [R]

Gib anschließend ein:

regedit

Bestätige mit [Enter].

Ein wichtiger Bereich für benutzerbezogene Autostarts lautet:

HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run

Hier können Startbefehle gespeichert sein, die beim Anmelden Deines Benutzerkontos ausgeführt werden.

Für systemweite Autostarts gibt es zusätzlich:

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Run

Unter einem üblichen 64-Bit-Windows existiert außerdem eine 32-Bit-Registrierungsansicht. Deren systemweiter Run-Bereich ist beispielsweise hier sichtbar:

HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\Windows\CurrentVersion\Run

In diesen Bereichen findest Du unter anderem Programmnamen und Startbefehle.

Ein solcher Befehl kann beispielsweise auf eine ausführbare Programmdatei verweisen.

Wichtig: Bearbeite Registry-Einträge nicht auf Verdacht. Ein versehentlich entfernter oder falsch geänderter Wert kann dazu führen, dass eine Anwendung nicht mehr richtig funktioniert.

Weitere Informationen findest Du in unserem Ratgeber „Regedit als Administrator öffnen“.

Was ist der Unterschied zwischen Run und RunOnce?

Neben dem Registry-Bereich Run gibt es auch RunOnce.

Der Unterschied ist einfach:

• Run: Ein Programm soll bei jeder entsprechenden Anmeldung gestartet werden.
• RunOnce: Ein Startbefehl ist grundsätzlich für eine einmalige Ausführung vorgesehen.

RunOnce wird beispielsweise bei Installations- und Einrichtungsvorgängen verwendet.

Solche Einträge solltest Du nicht einfach als überflüssige Autostarts betrachten.

5. Autostarts in der Windows-Aufgabenplanung prüfen

Programme können auch über die Windows-Aufgabenplanung automatisch gestartet werden.

Öffne sie mit:

[Windows] + [R]

Gib ein:

taskschd.msc

Bestätige mit [Enter].

In der Aufgabenplanung können Programme durch unterschiedliche Ereignisse gestartet werden.

Beispiele:

• Beim Start des Computers
• Bei der Anmeldung eines Benutzers
• Zu einer bestimmten Uhrzeit
• Bei bestimmten Windows-Ereignissen

Ein Programm kann daher möglicherweise automatisch gestartet werden, obwohl es im Task-Manager deaktiviert ist.

Prüfe in diesem Fall, ob das Programm eine geplante Aufgabe verwendet.

Aber Vorsicht: Viele Aufgaben gehören zu Windows oder zu benötigter Software. Entferne sie nicht einfach, weil Dir ihre Bezeichnung unbekannt ist.

6. Autostarts mit der Windows Toolbox überprüfen

Unsere kostenlose Windows Toolbox bietet eine eigene Autostart-Ansicht.

Sie hilft Dir, verschiedene Autostart-Einträge übersichtlich anzuzeigen und besser einzuordnen.

Du kannst damit beispielsweise erkennen:

• Welche Autostarts gefunden wurden.
• Ob ein Eintrag benutzerbezogen oder systemweit ist.
• Woher ein Autostart-Eintrag stammt.
• Welcher Aktivierungszustand angezeigt wird.

Dadurch musst Du nicht alle Windows-Werkzeuge und Registry-Bereiche einzeln durchsuchen.

Die Toolbox soll Dir dabei helfen, Windows-Einstellungen besser zu verstehen und bewusste Entscheidungen zu treffen.

Sie ist kein automatischer Registry-Cleaner und entfernt nicht wahllos Windows-Einträge.

Typische Autostart-Probleme erkennen und beheben

Wenn ein Autostart ungewöhnlich aussieht, bedeutet das nicht automatisch, dass ein Fehler vorliegt.

Die folgenden Fälle treten vergleichsweise häufig auf.

Ein deinstalliertes Programm steht weiterhin im Autostart

Du hast ein Programm deinstalliert, aber im Windows-Task-Manager wird es weiterhin unter „Autostart von Apps“ angezeigt?

Das kann passieren, wenn bei der Deinstallation nicht alle Autostart-Einstellungen entfernt wurden.

Bevor Du etwas löschst, solltest Du zunächst prüfen, ob noch ein funktionsfähiger Autostart vorhanden ist oder lediglich eine alte Information zurückgeblieben ist.

Schritt 1: Prüfen, ob das Programm wirklich deinstalliert wurde

1. Öffne mit [Windows] + [I] die Windows-Einstellungen.
2. Wähle Apps → Installierte Apps.
3. Suche nach dem Namen des betreffenden Programms.

Wird das Programm hier noch angezeigt, ist es möglicherweise weiterhin installiert. Beachte jedoch, dass nicht jede portable Anwendung in dieser Liste erscheint.

Schritt 2: Den Autostart-Eintrag untersuchen

1. Öffne den Task-Manager mit [Strg] + [Umschalt] + [Esc].
2. Wähle „Autostart von Apps“.
3. Suche den Eintrag des bereits deinstallierten Programms.
4. Klicke mit der rechten Maustaste darauf.
5. Wähle „Dateipfad öffnen“, sofern diese Funktion verfügbar ist.

Öffnet sich ein Ordner mit der zugehörigen Programmdatei, ist diese Datei noch vorhanden. Das bedeutet allerdings nicht zwangsläufig, dass das Programm noch vollständig installiert ist.

Ist „Dateipfad öffnen“ ausgegraut oder nicht verfügbar, lässt sich der Speicherort auf diesem Weg nicht feststellen. Das allein beweist noch keinen Fehler.

Schritt 3: Die Windows-Autostartordner überprüfen

Manchmal bleibt nach einer Deinstallation lediglich eine alte Programmverknüpfung zurück.

Prüfe deshalb den persönlichen Autostartordner:

1. Drücke [Windows] + [R].
2. Gib shell:startup ein und bestätige mit [Enter].
3. Suche nach einer Verknüpfung des deinstallierten Programms.
4. Falls Du eine findest, klicke sie mit der rechten Maustaste an und öffne die Eigenschaften.
5. Unter „Ziel“ kannst Du sehen, auf welches Programm die Verknüpfung verweist.

Ist das Programm tatsächlich nicht mehr vorhanden und benötigst Du die Verknüpfung nicht mehr, kannst Du sie entfernen.

Prüfe bei Bedarf auch den gemeinsamen Autostartordner mit shell:common startup. Änderungen dort können Administratorrechte erfordern.

Wichtig: Lösche ausschließlich die eindeutig zugeordnete, überflüssige Verknüpfung – keine unbekannten Dateien oder Programme.

Schritt 4: Was tun, wenn Du keinen passenden Eintrag findest?

Wenn Du das Programm bereits deinstalliert hast, aber keine entsprechende Verknüpfung findest, kann der Autostart an einer anderen Stelle gespeichert sein.

Dazu gehören beispielsweise alte Einträge in der Windows-Registrierung oder zurückgebliebene Aktivierungsinformationen.

Hier hilft Dir die kostenlose Windows Toolbox. Ihre Autostart-Ansicht zeigt Dir zusätzliche Informationen zur Herkunft der gefundenen Einträge und hilft bei der Einordnung.

Alternativ findest Du im Expertenbereich dieses Ratgebers weiterführende PowerShell-Anleitungen.

Musst Du den Eintrag unbedingt entfernen?

Nein. Wenn das Programm nicht mehr gestartet wird und keine Fehlermeldung erscheint, besteht normalerweise kein dringender Handlungsbedarf.

Ein alter Eintrag lässt sich gegebenenfalls zunächst im Task-Manager deaktivieren, sofern Windows diese Möglichkeit anbietet.

Eine allein zurückgebliebene Autostart-Statusinformation ist meist harmlos und verlangsamt Windows normalerweise nicht spürbar.

Unser Tipp: Entferne Autostart-Einträge nur dann, wenn Du ihre Herkunft sicher bestimmen kannst. Unbekannte Registry-Einträge solltest Du nicht auf Verdacht löschen.

Ein Autostart verweist auf ein nicht mehr vorhandenes Programm

Manchmal versucht Windows, ein Programm automatisch zu starten, dessen Datei nicht mehr vorhanden ist.

Das kann beispielsweise passieren, wenn ein Programm deinstalliert, verschoben oder unvollständig entfernt wurde.

Ein alter Startbefehl könnte dann noch auf folgende Datei verweisen:

C:\Programme\BeispielApp\Beispiel.exe

Existiert diese Datei nicht mehr, kann der automatische Start fehlschlagen.

Schritt 1: Den betroffenen Autostart überprüfen

1. Öffne mit [Strg] + [Umschalt] + [Esc] den Task-Manager.
2. Wähle links „Autostart von Apps“.
3. Suche nach dem betreffenden Programm.
4. Klicke mit der rechten Maustaste auf den Eintrag.
5. Wähle „Dateipfad öffnen“, sofern diese Funktion verfügbar ist.

Öffnet sich der entsprechende Programmordner, ist die zugeordnete Datei noch vorhanden.

Ist die Funktion ausgegraut oder lässt sich der Speicherort nicht öffnen, kann der Startbefehl ungültig sein. Das ist allerdings noch kein eindeutiger Beweis.

Schritt 2: Überprüfen, ob das Programm installiert ist

1. Öffne mit [Windows] + [I] die Windows-Einstellungen.
2. Wähle Apps → Installierte Apps.
3. Suche nach dem Namen des betreffenden Programms.

Das Programm ist noch installiert?

Versuche, es über das Startmenü normal zu öffnen.

Funktioniert es, aber der automatische Start nicht, überprüfe zunächst die Autostart-Einstellung innerhalb des Programms.

Falls die Anwendung eine Reparaturfunktion anbietet, kannst Du diese nutzen. Andernfalls kann eine Neuinstallation über die offizielle Herstellerseite helfen.

Das Programm ist nicht mehr installiert?

Wenn Du es nicht mehr benötigst, kannst Du den veralteten Autostart im Task-Manager zunächst deaktivieren.

Dazu klickst Du den betreffenden Eintrag mit der rechten Maustaste an und wählst „Deaktivieren“.

Starte anschließend Windows neu und kontrolliere, ob die bisherige Fehlermeldung verschwunden ist.

Schritt 3: Was tun, wenn der Eintrag weiterhin vorhanden ist?

Möglicherweise handelt es sich um einen zurückgebliebenen Registry-Eintrag oder eine alte Statusinformation.

Mit der Windows Toolbox kannst Du die Herkunft des Autostarts genauer untersuchen.

Alternativ findest Du im Expertenbereich dieses Ratgebers zusätzliche PowerShell-Anleitungen.

Wichtig: Ein Startbefehl kann auch besondere Parameter, Variablen oder andere Programmstarter enthalten. Deshalb bedeutet eine nicht unmittelbar auffindbare Datei nicht automatisch, dass der Eintrag gelöscht werden darf.

Ein Programm erscheint mehrfach im Autostart

Du öffnest den Task-Manager und stellst fest, dass ein Programm gleich mehrfach in der Autostart-Liste auftaucht?

Das muss nicht bedeuten, dass Windows einen Fehler gemacht hat.

Manche Programme richten mehrere automatische Startmöglichkeiten ein. Beispielsweise kann eine Anwendung einen Hintergrunddienst und zusätzlich ein Benachrichtigungsprogramm verwenden.

Es können aber auch tatsächlich doppelte Autostarts vorhanden sein.

Schritt 1: Die Einträge miteinander vergleichen

1. Öffne mit [Strg] + [Umschalt] + [Esc] den Task-Manager.
2. Wähle „Autostart von Apps“.
3. Suche nach den mehrfach angezeigten Programmeinträgen.
4. Vergleiche die Namen, Herausgeber und Aktivierungszustände.
5. Klicke die Einträge nacheinander mit der rechten Maustaste an und wähle jeweils „Dateipfad öffnen“, sofern verfügbar.

Achte darauf, ob die Einträge tatsächlich auf dieselbe Programmdatei verweisen.

Schritt 2: Prüfen, ob beide Autostarts benötigt werden

Wenn beide Einträge zum selben Programm gehören, solltest Du zunächst prüfen, welche Aufgaben sie übernehmen.

Ein Beispiel:

Ein Gerätehersteller verwendet möglicherweise einen Autostart für seine Steuerungssoftware und einen zweiten für zusätzliche Benachrichtigungen.

Beide Einträge können daher sinnvoll sein.

Sind die Einträge dagegen eindeutig identisch und wird einer davon nicht benötigt, kannst Du versuchsweise einen Autostart deaktivieren.

So gehst Du vor:

1. Markiere einen der beiden bekannten, optionalen Einträge.
2. Klicke auf „Deaktivieren“.
3. Starte Windows neu.
4. Prüfe, ob das Programm weiterhin wie gewünscht funktioniert.

Wenn wichtige Funktionen fehlen, kannst Du den Autostart im Task-Manager wieder aktivieren.

Schritt 3: Die Herkunft genauer untersuchen

Wenn Du nicht erkennen kannst, warum das Programm mehrfach erscheint, solltest Du keine Einträge auf Verdacht löschen.

Unsere Windows Toolbox hilft Dir dabei, die Herkunft und den Zustand der unterstützten Autostart-Einträge übersichtlich darzustellen.

Damit lassen sich beispielsweise benutzerbezogene und systemweite Einträge besser unterscheiden.

Wichtig: Zwei Einträge mit demselben Namen sind nicht automatisch doppelt oder fehlerhaft. Entscheidend ist, welcher Startbefehl dahintersteckt und welche Funktion er erfüllt.

Ein Autostart ist deaktiviert

Im Task-Manager steht bei einem Programm unter „Status“ der Hinweis „Deaktiviert“?

Das ist normalerweise vollkommen in Ordnung.

Es bedeutet lediglich, dass Windows dieses Programm über den betreffenden Autostart nicht automatisch ausführen soll.

Möglicherweise hast Du die Funktion früher selbst deaktiviert, oder eine andere berechtigte Einstellung hat den Zustand verändert.

Musst Du etwas unternehmen?

Nein. Wenn Du das Programm nicht automatisch benötigst, kannst Du den Eintrag einfach deaktiviert lassen.

Das Programm bleibt installiert und lässt sich weiterhin normal öffnen.

Du möchtest den Autostart wieder aktivieren?

1. Öffne den Task-Manager mit [Strg] + [Umschalt] + [Esc].
2. Wähle „Autostart von Apps“.
3. Suche das betreffende Programm.
4. Klicke es mit der rechten Maustaste an.
5. Wähle „Aktivieren“.

Bei der nächsten Anmeldung kann das Programm wieder automatisch über diesen Autostart gestartet werden.

Wichtig: Ein deaktivierter Autostart ist weder beschädigt noch fehlerhaft. Er muss nicht repariert, bereinigt oder gelöscht werden.

Ein deaktiviertes Programm startet trotzdem automatisch

Du hast ein Programm im Task-Manager deaktiviert, aber nach einem Neustart wird es trotzdem wieder geöffnet?

Das kann mehrere Ursachen haben.

Manche Programme besitzen eigene Autostart-Einstellungen. Andere verwenden zusätzliche Windows-Startmechanismen.

Außerdem kann Windows bestimmte zuvor geöffnete Anwendungen bei der nächsten Anmeldung automatisch wiederherstellen.

Schritt 1: Die Einstellungen des Programms überprüfen

Öffne zunächst das betreffende Programm.

Suche in dessen Einstellungen nach Bezeichnungen wie:

• „Mit Windows starten“
• „Beim Anmelden automatisch starten“
• „Beim Systemstart öffnen“
• „Automatisch im Hintergrund starten“

Falls Du eine entsprechende Einstellung findest und den automatischen Start nicht möchtest, deaktiviere sie.

Starte Windows danach neu und prüfe, ob das Programm weiterhin automatisch geöffnet wird.

Schritt 2: Den Autostart in Windows erneut überprüfen

1. Öffne mit [Windows] + [I] die Einstellungen.
2. Wähle Apps → Autostart.
3. Suche das betreffende Programm.
4. Kontrolliere, ob der Schalter ausgeschaltet ist.

Falls der Autostart inzwischen wieder aktiviert wurde, kannst Du ihn erneut deaktivieren.

Manche Programme ändern ihre Autostart-Einstellungen beispielsweise nach einer Aktualisierung.

Schritt 3: Die automatische Wiederherstellung von Anwendungen prüfen

Windows kann bestimmte zuvor geöffnete Programme nach einer erneuten Anmeldung automatisch wiederherstellen.

Das ist nicht dasselbe wie ein gewöhnlicher Autostart.

So überprüfst Du die Einstellung:

1. Öffne mit [Windows] + [I] die Windows-Einstellungen.
2. Wähle Konten → Anmeldeoptionen.
3. Suche nach der Option „Meine neu startbaren Apps automatisch speichern und neu starten, wenn ich mich wieder anmelde“ oder einer sinngemäß bezeichneten Einstellung.
4. Deaktiviere diese Option versuchsweise, wenn Du nicht möchtest, dass unterstützte Anwendungen automatisch wieder geöffnet werden.

Starte Deinen Computer anschließend neu und prüfe das Verhalten.

Schritt 4: Die Windows-Aufgabenplanung überprüfen

Falls das Programm noch immer automatisch gestartet wird, kann eine geplante Aufgabe dafür verantwortlich sein.

So überprüfst Du das:

1. Drücke [Windows] + [R].
2. Gib taskschd.msc ein und bestätige mit [Enter].
3. Wähle links „Aufgabenplanungsbibliothek“.
4. Suche nach einer Aufgabe, die eindeutig zum betreffenden Programm gehört. Manche Hersteller legen ihre Aufgaben in Unterordnern ab.
5. Markiere die Aufgabe und prüfe unten die Registerkarten „Trigger“ und „Aktionen“.

Unter „Trigger“ siehst Du, wodurch eine Aufgabe gestartet wird.

Unter „Aktionen“ kannst Du erkennen, welches Programm oder welcher Befehl ausgeführt werden soll.

Findest Du eine eindeutig zugeordnete Aufgabe, die das unerwünschte Programm startet?

Wenn Du sicher bist, dass sie nicht für andere Funktionen benötigt wird, kannst Du sie über einen Rechtsklick zunächst deaktivieren.

Lösche sie nicht sofort. Eine deaktivierte Aufgabe kannst Du bei Bedarf wieder aktivieren.

Achtung: Verändere keine unbekannten Aufgaben und insbesondere keine Windows-Systemaufgaben auf Verdacht.

Schritt 5: Weitere Autostart-Einträge untersuchen

Wenn die bisherigen Schritte das Problem nicht lösen, kann das Programm über einen zusätzlichen Registry-Eintrag oder einen anderen Startmechanismus gestartet werden.

Hier kann die Windows Toolbox bei der weiteren Untersuchung helfen.

Für fortgeschrittene Nutzer stehen im Expertenbereich zusätzliche PowerShell-Anleitungen bereit.

Wichtig: Nicht jedes automatisch gestartete Hintergrundprogramm erscheint im Task-Manager unter „Autostart von Apps“. Deshalb sollte bei einem solchen Problem immer zunächst der tatsächliche Startmechanismus ermittelt werden.

Verwaiste Autostart-Einträge: Was bedeutet StartupApproved?

Ein besonderer Fall sind sogenannte verwaiste Autostart-Statusinformationen.

Solche Informationen können beispielsweise nach der Deinstallation eines Programms zurückbleiben.

Um sie richtig einzuordnen, müssen wir zwischen einem Startbefehl und dem gespeicherten Aktivierungszustand unterscheiden.

Was ist StartupApproved?

Windows verwendet Registry-Bereiche mit dem Namen StartupApproved.

Dort können Informationen über den Aktivierungszustand von Autostart-Einträgen gespeichert werden.

Ein typischer benutzerbezogener Speicherort lautet:

HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\StartupApproved

Darunter können verschiedene Unterbereiche vorhanden sein.

Beispiele:

• Run
• Run32
• StartupFolder

Diese Bereiche enthalten Informationen, die Windows im Zusammenhang mit der Autostart-Verwaltung verwendet.

Wichtig: Ein StartupApproved-Wert ist nicht dasselbe wie der eigentliche Startbefehl eines Programms.

Was ist der Unterschied zwischen Run und StartupApproved?

Ein Beispiel macht den Unterschied deutlich.

Angenommen, Du hast ein Programm namens „BeispielApp“ installiert.

Das Programm richtet folgenden Startbefehl ein:

BeispielApp = "C:\Programme\BeispielApp\Beispiel.exe"

Dieser Eintrag kann im entsprechenden Run-Bereich gespeichert sein.

Er sagt Windows vereinfacht:

„Starte dieses Programm bei der Anmeldung.“

Zusätzlich kann Windows einen zugehörigen Aktivierungszustand unter StartupApproved speichern.

Dieser enthält normalerweise Binärdaten, die nicht wie gewöhnlicher Text lesbar sind.

Damit haben wir zwei unterschiedliche Informationen:

Information	Aufgabe
Run	Enthält den eigentlichen Startbefehl
StartupApproved	Enthält ergänzende Statusinformationen
Run32 innerhalb von StartupApproved	Steht im Zusammenhang mit bestimmten 32-Bit-Autostarts
StartupFolder innerhalb von StartupApproved	Steht im Zusammenhang mit Autostartordner-Einträgen

Ein alleiniger StartupApproved-Statuswert startet kein Programm.

Was bedeutet Run32?

Auf 64-Bit-Windows können bestimmte Registry-Bereiche in getrennten 32-Bit- und 64-Bit-Ansichten vorhanden sein.

Ein 32-Bit-Programm kann seinen Startbefehl beispielsweise in der entsprechenden 32-Bit-Ansicht des systemweiten Run-Bereichs speichern.

Windows kann dazu Statusinformationen unter StartupApproved\Run32 verwalten.

Run32 ist dabei kein allgemeiner eigenständiger Startbefehl-Schlüssel.

Bei einer Prüfung muss daher der tatsächliche Startbefehl in der passenden Registry-Ansicht gesucht werden.

Was bedeutet StartupFolder?

Der Statusbereich StartupFolder steht im Zusammenhang mit Autostarts aus den Windows-Autostartordnern.

Hier ist das passende Gegenstück normalerweise kein Registry-Run-Befehl, sondern ein Eintrag im betreffenden Autostartordner.

Deshalb reicht es nicht aus, nur die Run-Schlüssel zu durchsuchen.

Auch der richtige Benutzerkontext muss berücksichtigt werden.

Warum bleiben StartupApproved-Einträge nach einer Deinstallation zurück?

Stell Dir folgende Situation vor:

1. Du installierst die „BeispielApp“.
2. Das Programm richtet einen automatischen Start ein.
3. Du deaktivierst diesen Autostart später im Task-Manager.
4. Windows speichert den entsprechenden Aktivierungszustand.
5. Einige Zeit danach deinstallierst Du die Anwendung.

Bei der Deinstallation wird möglicherweise der eigentliche Startbefehl entfernt.

Die frühere Statusinformation bleibt jedoch bestehen.

Damit ist ein gespeicherter Aktivierungszustand vorhanden, obwohl der ursprüngliche Startbefehl nicht mehr existiert.

Man spricht dann von einer möglicherweise verwaisten Autostart-Statusinformation.

Sind verwaiste StartupApproved-Einträge gefährlich?

Normalerweise nicht.

Eine allein zurückgebliebene Statusinformation führt keinen Programmstart aus.

Sie ist deshalb für sich genommen kein Hinweis auf Schadsoftware oder eine Beschädigung von Windows.

Solche Einträge können häufig problemlos bestehen bleiben.

Wann sollte man verwaiste Autostart-Einträge bereinigen?

Eine gezielte Bereinigung kann sinnvoll sein, wenn:

• die Herkunft des Eintrags eindeutig geklärt wurde,
• kein zugehöriger Startbefehl beziehungsweise keine passende Verknüpfung mehr vorhanden ist,
• der richtige Benutzer- und Registry-Bereich geprüft wurde,
• keine andere benötigte Funktion betroffen ist,
• und zuvor eine geeignete Sicherung erstellt wurde.

Eine Bereinigung ist aber nicht zwingend notwendig.

Ein verwaister Statuswert verursacht normalerweise keinen messbaren Leistungsnachteil.

Wenn Du die Herkunft nicht sicher bestimmen kannst, solltest Du zunächst nichts entfernen.

Benutzerrechte und Administratorrechte verstehen

Bei Autostart-Einträgen ist wichtig, ob eine Einstellung nur für Deinen Benutzer oder für den gesamten Computer gilt.

Was bedeutet HKCU?

HKCU ist die Abkürzung für:

HKEY_CURRENT_USER

Dieser Registry-Bereich enthält Einstellungen des Benutzerkontos, unter dessen Identität das betreffende Programm ausgeführt wird.

Viele persönliche Autostarts befinden sich hier.

Solche Werte lassen sich häufig ohne Administratorrechte lesen und verändern.

Was bedeutet HKLM?

HKLM steht für:

HKEY_LOCAL_MACHINE

Dieser Bereich enthält Einstellungen, die den gesamten Computer betreffen können.

Systemweite Autostarts befinden sich häufig in entsprechenden Unterbereichen.

Für Änderungen können Administratorrechte notwendig sein.

Warum gibt es unterschiedliche Registry-Ansichten?

Auf 64-Bit-Windows gibt es für bestimmte Registry-Bereiche getrennte 32-Bit- und 64-Bit-Ansichten.

Das betrifft insbesondere Teile von:

HKEY_LOCAL_MACHINE\SOFTWARE

Ein Diagnoseskript muss diese Ansichten ausdrücklich berücksichtigen, damit es keine Einträge übersieht.

Nicht sämtliche Registry-Bereiche sind jedoch getrennt. Der benutzerbezogene Bereich HKCU\SOFTWARE wird grundsätzlich gemeinsam genutzt, sofern keine besondere Ausnahme gilt.

Was ist die Benutzerkontensteuerung (UAC)?

Die Benutzerkontensteuerung schützt Windows vor unberechtigten Änderungen an wichtigen Systemeinstellungen.

Wenn Du einen geschützten Bereich verändern möchtest, kann Windows eine Bestätigung oder Administrator-Zugangsdaten verlangen.

Das ist eine normale Sicherheitsfunktion.

Für Experten: Autostarts mit PowerShell untersuchen und gezielt bereinigen

Die bisherigen Anleitungen reichen für die meisten Windows-Nutzer vollkommen aus.

Die folgenden Beispiele richten sich ausdrücklich an fortgeschrittene Anwender, die Registry-Einträge genauer untersuchen möchten.

Hier geht es unter anderem um:

• benutzerbezogene und systemweite Run-Einträge,
• 32-Bit- und 64-Bit-Registry-Ansichten,
• StartupApproved-Statusinformationen,
• das Erkennen möglicher Restwerte,
• das Sichern einzelner Registry-Werte,
• deren gezielte Bereinigung und Wiederherstellung.

PowerShell öffnen

Für lesende Diagnosen reicht normalerweise eine reguläre Windows-PowerShell.

Öffne das Startmenü und suche nach:

Windows PowerShell

Starte das Programm.

Für Änderungen an geschützten HKLM-Bereichen kann eine Ausführung als Administrator notwendig sein.

Alle nachfolgenden Skripte können direkt kopiert und in PowerShell eingefügt werden. Es müssen keine zusätzlichen Skriptdateien heruntergeladen werden.

PS-1: Autostart-Programme auflisten

Mit der Windows-Verwaltungsklasse Win32_StartupCommand lassen sich viele klassische Autostart-Befehle anzeigen.

Get-CimInstance -ClassName Win32_StartupCommand |
    Select-Object Name, Command, Location, User, UserSID |
    Sort-Object User, Name |
    Format-List

Die Ausgabe enthält unter anderem den Namen, den gespeicherten Befehl und die Benutzerzuordnung.

Einschränkung: Die Klasse kann erhöhte Berechtigungen benötigen. Außerdem erfasst sie nicht sämtliche Windows-Dienste, geplanten Aufgaben und sonstigen Startmechanismen.

PS-2: Run-Einträge aus HKCU und HKLM auslesen

Das nächste Skript liest die klassischen Run-Einträge des aktuellen Benutzers sowie die systemweiten Registry-Ansichten.

Es berücksichtigt 32-Bit- und 64-Bit-Bereiche ausdrücklich.

Das Skript arbeitet ausschließlich lesend.

& {
    $ErrorActionPreference = 'Stop'
    $pfad = 'SOFTWARE\Microsoft\Windows\CurrentVersion\Run'

    $ziele = @(
        [pscustomobject]@{
            Bereich = 'HKCU'
            Hive = [Microsoft.Win32.RegistryHive]::CurrentUser
            View = [Microsoft.Win32.RegistryView]::Default
        }
    )

    if ([Environment]::Is64BitOperatingSystem) {
        $ziele += [pscustomobject]@{
            Bereich = 'HKLM 64-Bit'
            Hive = [Microsoft.Win32.RegistryHive]::LocalMachine
            View = [Microsoft.Win32.RegistryView]::Registry64
        }
        $ziele += [pscustomobject]@{
            Bereich = 'HKLM 32-Bit'
            Hive = [Microsoft.Win32.RegistryHive]::LocalMachine
            View = [Microsoft.Win32.RegistryView]::Registry32
        }
    }
    else {
        $ziele += [pscustomobject]@{
            Bereich = 'HKLM'
            Hive = [Microsoft.Win32.RegistryHive]::LocalMachine
            View = [Microsoft.Win32.RegistryView]::Default
        }
    }

    foreach ($ziel in $ziele) {
        try {
            $basis = [Microsoft.Win32.RegistryKey]::OpenBaseKey(
                $ziel.Hive, $ziel.View
            )
            try {
                $key = $basis.OpenSubKey($pfad, $false)
                if ($null -eq $key) { continue }

                try {
                    foreach ($name in $key.GetValueNames()) {
                        [pscustomobject]@{
                            Bereich = $ziel.Bereich
                            Name = $name
                            Datentyp = $key.GetValueKind($name).ToString()
                            Befehl = [string]$key.GetValue(
                                $name,
                                $null,
                                [Microsoft.Win32.RegistryValueOptions]::DoNotExpandEnvironmentNames
                            )
                        }
                    }
                }
                finally { $key.Dispose() }
            }
            finally { $basis.Dispose() }
        }
        catch {
            Write-Warning "$($ziel.Bereich): $($_.Exception.Message)"
        }
    }
} | Format-List

Das Skript zeigt den ursprünglichen Startbefehl an.

Es verändert keine Registry-Werte und versucht nicht, Programme anhand ihrer Pfade automatisch als fehlerhaft einzustufen.

PS-3: Möglicherweise verwaiste StartupApproved-Einträge erkennen

Dieses Skript erweitert die Diagnose auf folgende Statusbereiche:

• HKCU – Run
• HKLM – Run
• HKLM – Run32
• HKCU – StartupFolder
• HKLM – StartupFolder

Bei Run-Einträgen prüft es die zugehörigen Registry-Bereiche.

Bei StartupFolder werden die entsprechenden Autostartordner berücksichtigt.

Auch dieses Skript arbeitet ausschließlich lesend.

& {
    $ErrorActionPreference = 'Stop'

    $statusRoot = 'SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\StartupApproved'
    $runPath = 'SOFTWARE\Microsoft\Windows\CurrentVersion\Run'

    $cu = [Microsoft.Win32.RegistryHive]::CurrentUser
    $lm = [Microsoft.Win32.RegistryHive]::LocalMachine
    $def = [Microsoft.Win32.RegistryView]::Default
    $r64 = [Microsoft.Win32.RegistryView]::Registry64
    $r32 = [Microsoft.Win32.RegistryView]::Registry32

    $faelle = @(
        [pscustomobject]@{
            Bereich='HKCU Run'; Hive=$cu; View=$def
            Status='Run'; GegenView=$def; Typ='Run'
        },
        [pscustomobject]@{
            Bereich='HKCU StartupFolder'; Hive=$cu; View=$def
            Status='StartupFolder'; GegenView=$def; Typ='Folder'
        }
    )

    if ([Environment]::Is64BitOperatingSystem) {
        $faelle += [pscustomobject]@{
            Bereich='HKLM Run 64'; Hive=$lm; View=$r64
            Status='Run'; GegenView=$r64; Typ='Run'
        }
        $faelle += [pscustomobject]@{
            Bereich='HKLM Run32'; Hive=$lm; View=$r64
            Status='Run32'; GegenView=$r32; Typ='Run'
        }
        $faelle += [pscustomobject]@{
            Bereich='HKLM StartupFolder'; Hive=$lm; View=$r64
            Status='StartupFolder'; GegenView=$r64; Typ='Folder'
        }
    }
    else {
        $faelle += [pscustomobject]@{
            Bereich='HKLM Run'; Hive=$lm; View=$def
            Status='Run'; GegenView=$def; Typ='Run'
        }
        $faelle += [pscustomobject]@{
            Bereich='HKLM StartupFolder'; Hive=$lm; View=$def
            Status='StartupFolder'; GegenView=$def; Typ='Folder'
        }
    }

    foreach ($f in $faelle) {
        $basis = $null
        $gegenBasis = $null
        $status = $null
        $gegen = $null

        try {
            $basis = [Microsoft.Win32.RegistryKey]::OpenBaseKey(
                $f.Hive, $f.View
            )
            $status = $basis.OpenSubKey(
                ($statusRoot + '\' + $f.Status), $false
            )

            if ($null -eq $status) { continue }

            if ($f.Typ -eq 'Run') {
                $gegenBasis = [Microsoft.Win32.RegistryKey]::OpenBaseKey(
                    $f.Hive, $f.GegenView
                )
                $gegen = $gegenBasis.OpenSubKey($runPath, $false)
            }
            else {
                $ordnerName = if ($f.Hive -eq $cu) {
                    'Startup'
                } else {
                    'CommonStartup'
                }
                $ordner = [Environment]::GetFolderPath($ordnerName)

                if ([string]::IsNullOrWhiteSpace($ordner) -or
                    -not [IO.Directory]::Exists($ordner)) {
                    throw 'Autostartordner nicht lesbar.'
                }
            }

            foreach ($name in $status.GetValueNames()) {
                $datentyp = $status.GetValueKind($name).ToString()
                $vorhanden = $false
                $bewertung = 'Nicht eindeutig beurteilbar'

                if ($datentyp -eq 'Binary') {
                    if ($f.Typ -eq 'Run') {
                        if ($null -ne $gegen) {
                            $vorhanden = $gegen.GetValueNames() -contains $name
                        }

                        # Zusaetzliche HKCU-Wow6432Node-Konstellationen
                        # benoetigen gegebenenfalls manuelle Pruefung.
                    }
                    else {
                        if ([IO.Path]::GetFileName($name) -eq $name) {
                            $datei = Join-Path $ordner $name
                            $vorhanden = (
                                [IO.File]::Exists($datei) -or
                                [IO.Directory]::Exists($datei)
                            )
                        }
                    }

                    $bewertung = if ($vorhanden) {
                        'Passendes Gegenstueck gefunden'
                    } else {
                        'Moegliche Restinformation - manuell pruefen'
                    }
                }

                [pscustomobject]@{
                    Bereich = $f.Bereich
                    Name = $name
                    Datentyp = $datentyp
                    Gegenstueck = $vorhanden
                    Bewertung = $bewertung
                }
            }
        }
        catch {
            Write-Warning "$($f.Bereich): Pruefung unvollstaendig - $($_.Exception.Message)"
        }
        finally {
            if ($null -ne $gegen) { $gegen.Dispose() }
            if ($null -ne $gegenBasis) { $gegenBasis.Dispose() }
            if ($null -ne $status) { $status.Dispose() }
            if ($null -ne $basis) { $basis.Dispose() }
        }
    }
} | Format-Table -AutoSize -Wrap

Die Ergebnisse sind Hinweise, keine endgültigen Fehlerdiagnosen.

Insbesondere bei 32-Bit-Autostarts, ungewöhnlichen Benutzerkonfigurationen oder besonderen Dateizuordnungen können zusätzliche Prüfungen erforderlich sein.

Wenn das Skript einen möglichen Restwert meldet, bedeutet das nicht automatisch, dass dieser bedenkenlos entfernt werden darf.

PS-5 bis PS-7: Registry-Werte sichern, gezielt bereinigen und wiederherstellen

Die folgenden drei Funktionen gehören zusammen:

PS-5 – Sicherung: Ein ausgewählter binärer Statuswert wird mit seiner genauen Herkunft und den Originaldaten gesichert.

PS-6 – Bereinigung: Ein zuvor gesicherter Statuswert kann nach erneuter Prüfung und ausdrücklicher Bestätigung einzeln entfernt werden.

PS-7 – Wiederherstellung: Ein gesicherter Wert kann bei Bedarf zurückgeschrieben werden, ohne vorhandene abweichende Daten zu überschreiben.

Damit die Sicherheitslogik nicht dreimal im Artikel wiederholt werden muss, sind die Funktionen in einem gemeinsamen Copy-&-Paste-Block zusammengefasst. Nach dem Einfügen wählst Du die gewünschte Aktion 5, 6 oder 7.

Wichtige Einschränkung: Dieser Expertenblock ist eine verallgemeinerte technische Fassung. Die zugrunde liegenden Registry-Operationen wurden mit künstlichen Testdaten geprüft; der gesamte folgende interaktive Block wurde jedoch nicht in allen realen Windows-Konstellationen vollständig abgenommen. Verwende ihn deshalb nicht ungeprüft für produktive Registry-Bereinigungen. Insbesondere ein fehlendes Gegenstück ist allein noch keine sichere Löschfreigabe.

& {
    $ErrorActionPreference = 'Stop'

    $statusRoot = 'SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\StartupApproved'
    $runPfad = 'SOFTWARE\Microsoft\Windows\CurrentVersion\Run'

    $scopeMap = @{
        '1' = @{ Label='HKCU Run'; Hive='CurrentUser'; Status='Run'; StatusView='Default'; GegenView='Default'; GegenTyp='Run' }
        '2' = @{ Label='HKLM Run 64'; Hive='LocalMachine'; Status='Run'; StatusView='Registry64'; GegenView='Registry64'; GegenTyp='Run' }
        '3' = @{ Label='HKLM Run32'; Hive='LocalMachine'; Status='Run32'; StatusView='Registry64'; GegenView='Registry32'; GegenTyp='Run' }
        '4' = @{ Label='HKCU StartupFolder'; Hive='CurrentUser'; Status='StartupFolder'; StatusView='Default'; GegenView='Default'; GegenTyp='Folder' }
        '5' = @{ Label='HKLM StartupFolder'; Hive='LocalMachine'; Status='StartupFolder'; StatusView='Registry64'; GegenView='Registry64'; GegenTyp='Folder' }
    }

    function Open-KNWBase([string]$Hive, [string]$View) {
        $h = [Enum]::Parse([Microsoft.Win32.RegistryHive], $Hive)
        $v = [Enum]::Parse([Microsoft.Win32.RegistryView], $View)
        [Microsoft.Win32.RegistryKey]::OpenBaseKey($h, $v)
    }

    function Hash-KNW([byte[]]$Data) {
        $sha = [Security.Cryptography.SHA256]::Create()
        try {
            [BitConverter]::ToString($sha.ComputeHash($Data)).Replace('-', '')
        }
        finally { $sha.Dispose() }
    }

    function Read-KNWBackup([string]$Datei) {
        $b = Get-Content -LiteralPath $Datei -Raw -Encoding UTF8 |
            ConvertFrom-Json

        if ($b.Format -cne 'KNW-Autostart-Einzelwert-v1' -or
            $b.Scope -notin @('1','2','3','4','5')) {
            throw 'Unbekanntes Sicherungsformat.'
        }

        $s = $scopeMap[[string]$b.Scope]
        $sid = [Security.Principal.WindowsIdentity]::GetCurrent().User.Value

        if ($b.SID -cne $sid -or
            $b.Label -cne $s.Label -or
            $b.Hive -cne $s.Hive -or
            $b.View -cne $s.StatusView -or
            $b.Key -cne ($statusRoot + '\' + $s.Status) -or
            $b.Kind -cne 'Binary' -or
            [string]::IsNullOrWhiteSpace([string]$b.Name)) {
            throw 'Sicherung stammt aus einem anderen Kontext.'
        }

        [byte[]]$bytes = [Convert]::FromBase64String([string]$b.Data)

        if ($bytes.Length -lt 4 -or
            (Hash-KNW $bytes) -cne $b.SHA256) {
            throw 'Sicherung beschaedigt oder unplausibel.'
        }

        [pscustomobject]@{
            Backup = $b
            Scope = $s
            Bytes = $bytes
        }
    }

    function Check-KNWCounterpart($Scope, [string]$Name) {
        if ($Scope.GegenTyp -eq 'Run') {
            $base = Open-KNWBase $Scope.Hive $Scope.GegenView
            try {
                $key = $base.OpenSubKey($runPfad, $false)
                if ($null -ne $key) {
                    try {
                        if ($key.GetValueNames() -contains $Name) {
                            return $true
                        }
                    }
                    finally { $key.Dispose() }
                }

                # Bei HKCU auch moegliche abweichende
                # Wow6432Node-Run-Eintraege beruecksichtigen.
                if ($Scope.Hive -eq 'CurrentUser') {
                    $extra = $base.OpenSubKey(
                        'SOFTWARE\Wow6432Node\Microsoft\Windows\CurrentVersion\Run',
                        $false
                    )
                    if ($null -ne $extra) {
                        try {
                            if ($extra.GetValueNames() -contains $Name) {
                                return $true
                            }
                        }
                        finally { $extra.Dispose() }
                    }
                }
                return $false
            }
            finally { $base.Dispose() }
        }

        if ([IO.Path]::GetFileName($Name) -cne $Name -or
            $Name.IndexOfAny([IO.Path]::GetInvalidFileNameChars()) -ge 0) {
            throw 'Kein sicher zuordenbarer Dateiname.'
        }

        $folderName = if ($Scope.Hive -eq 'CurrentUser') {
            'Startup'
        } else {
            'CommonStartup'
        }

        $folder = [Environment]::GetFolderPath($folderName)

        if ([string]::IsNullOrWhiteSpace($folder) -or
            -not [IO.Directory]::Exists($folder)) {
            throw 'Autostartordner nicht lesbar.'
        }

        return (
            [IO.File]::Exists((Join-Path $folder $Name)) -or
            [IO.Directory]::Exists((Join-Path $folder $Name))
        )
    }

    Write-Host 'KNW AUTOSTART - EXPERTENBEREICH'
    Write-Host '5 = Sichern, 6 = Entfernen, 7 = Wiederherstellen'

    $aktion = Read-Host 'Aktion eingeben (5, 6 oder 7)'

    if ($aktion -notin @('5','6','7')) {
        throw 'Keine gueltige Aktion.'
    }

    if ($aktion -eq '5') {
        Write-Host '1: HKCU Run'
        Write-Host '2: HKLM Run 64'
        Write-Host '3: HKLM Run32'
        Write-Host '4: HKCU StartupFolder'
        Write-Host '5: HKLM StartupFolder'

        $nr = Read-Host 'Bereich waehlen (1-5)'

        if (-not $scopeMap.ContainsKey($nr)) {
            throw 'Ungueltiger Bereich.'
        }

        if (-not [Environment]::Is64BitOperatingSystem -and
            $nr -in @('2','3','5')) {
            throw 'Dieser Bereich erfordert 64-Bit-Windows.'
        }

        $s = $scopeMap[$nr]
        $name = Read-Host 'Exakten Statuswertnamen eingeben'

        if ([string]::IsNullOrWhiteSpace($name)) {
            throw 'Name fehlt.'
        }

        $base = Open-KNWBase $s.Hive $s.StatusView
        try {
            $key = $base.OpenSubKey(
                ($statusRoot + '\' + $s.Status), $false
            )
            if ($null -eq $key) {
                throw 'Statusschluessel fehlt.'
            }

            try {
                if ($key.GetValueNames() -notcontains $name -or
                    $key.GetValueKind($name) -ne
                    [Microsoft.Win32.RegistryValueKind]::Binary) {
                    throw 'Wert fehlt oder Datentyp ist nicht REG_BINARY.'
                }
                [byte[]]$bytes = $key.GetValue($name)
            }
            finally { $key.Dispose() }
        }
        finally { $base.Dispose() }

        $backup = [pscustomobject]@{
            Format='KNW-Autostart-Einzelwert-v1'
            Scope=$nr
            Label=$s.Label
            SID=[Security.Principal.WindowsIdentity]::GetCurrent().User.Value
            Hive=$s.Hive
            View=$s.StatusView
            Key=($statusRoot + '\' + $s.Status)
            Name=$name
            Kind='Binary'
            Data=[Convert]::ToBase64String($bytes)
            SHA256=(Hash-KNW $bytes)
        }

        $dir = Join-Path (
            [Environment]::GetFolderPath('MyDocuments')
        ) 'KNW-Autostart-Sicherungen'

        New-Item -ItemType Directory -Path $dir -Force |
            Out-Null

        $file = Join-Path $dir (
            'KNW-' + [guid]::NewGuid().ToString('N') + '.json'
        )

        $backup | ConvertTo-Json |
            Out-File -LiteralPath $file -Encoding UTF8 -NoClobber

        $probe = Read-KNWBackup $file

        if ($probe.Backup.Data -cne $backup.Data -or
            $probe.Backup.Name -cne $name) {
            throw 'Sicherungspruefung fehlgeschlagen.'
        }

        Write-Host "Sicherung erfolgreich: $file"
    }
    else {
        $file = Read-Host 'Vollstaendigen Sicherungsdateipfad eingeben'
        $probe = Read-KNWBackup $file

        $b = $probe.Backup
        $s = $probe.Scope
        $bytes = $probe.Bytes
        $name = [string]$b.Name

        if (-not [Environment]::Is64BitOperatingSystem -and
            $b.Scope -in @('2','3','5')) {
            throw 'Dieser Bereich erfordert 64-Bit-Windows.'
        }

        $base = Open-KNWBase $s.Hive $s.StatusView

        try {
            $key = $base.OpenSubKey($b.Key, $true)

            if ($null -eq $key) {
                throw 'Statusschluessel fehlt oder Schreibrecht fehlt.'
            }

            try {
                $vorhanden = $key.GetValueNames() -contains $name

                if ($aktion -eq '6') {
                    if (-not $vorhanden -or
                        $key.GetValueKind($name) -ne
                        [Microsoft.Win32.RegistryValueKind]::Binary -or
                        [Convert]::ToBase64String(
                            [byte[]]$key.GetValue($name)
                        ) -cne $b.Data) {
                        throw 'Statuswert fehlt oder wurde veraendert.'
                    }

                    if (Check-KNWCounterpart $s $name) {
                        throw 'Gegenstueck vorhanden. Keine Bereinigung.'
                    }

                    Write-Host "Bereich: $($s.Label)"
                    Write-Host "Wert: $name"
                    Write-Warning 'Ein fehlendes Gegenstueck beweist nicht, dass die Entfernung folgenlos ist.'

                    $best = Read-Host "Exakt LOESCHEN $name eingeben"

                    if ($best -cne "LOESCHEN $name") {
                        Write-Host 'Abgebrochen.'
                        return
                    }

                    if (Check-KNWCounterpart $s $name) {
                        throw 'Gegenstueck inzwischen vorhanden.'
                    }

                    if ($key.GetValueNames() -notcontains $name -or
                        $key.GetValueKind($name) -ne
                        [Microsoft.Win32.RegistryValueKind]::Binary -or
                        [Convert]::ToBase64String(
                            [byte[]]$key.GetValue($name)
                        ) -cne $b.Data) {
                        throw 'Zustand wurde geaendert.'
                    }

                    $key.DeleteValue($name, $true)

                    if ($key.GetValueNames() -contains $name) {
                        throw 'Loeschung nicht bestaetigt.'
                    }

                    Write-Host 'Einzelwert entfernt.'
                    Write-Host 'Sicherung unbedingt aufbewahren.'
                }
                else {
                    if ($vorhanden) {
                        throw 'Statuswert existiert bereits. Keine Ueberschreibung.'
                    }

                    $best = Read-Host "Exakt WIEDERHERSTELLEN $name eingeben"

                    if ($best -cne "WIEDERHERSTELLEN $name") {
                        Write-Host 'Abgebrochen.'
                        return
                    }

                    if ($key.GetValueNames() -contains $name) {
                        throw 'Wert wurde inzwischen angelegt.'
                    }

                    $key.SetValue(
                        $name,
                        $bytes,
                        [Microsoft.Win32.RegistryValueKind]::Binary
                    )

                    if ($key.GetValueKind($name) -ne
                        [Microsoft.Win32.RegistryValueKind]::Binary -or
                        [Convert]::ToBase64String(
                            [byte[]]$key.GetValue($name)
                        ) -cne $b.Data) {
                        throw 'Wiederherstellung nicht korrekt.'
                    }

                    Write-Host 'Einzelwert bytegenau wiederhergestellt.'
                }
            }
            finally { $key.Dispose() }
        }
        finally { $base.Dispose() }
    }
}

Warum sollte man keine automatische Komplettbereinigung verwenden?

Windows besitzt verschiedene Mechanismen für automatische Programmstarts.

Außerdem können Startbefehle Umgebungsvariablen, Parameter oder besondere Programmstarter enthalten.

Ein fehlender Dateipfad oder ein scheinbar nicht zuordenbarer Statuswert ist daher kein ausreichender Grund für eine automatische Löschung.

Eine pauschale Bereinigung könnte benötigte Einstellungen entfernen oder bewusst deaktivierte Autostarts falsch bewerten.

Deshalb gilt auch für Experten: Diagnose und Bereinigung müssen getrennt bleiben.

Windows Toolbox: Autostarts bequem prüfen und verwalten

Wenn Du die verschiedenen Windows-Werkzeuge und Registry-Bereiche nicht selbst durchsuchen möchtest, bietet unsere Windows Toolbox eine übersichtliche Ergänzung.

Sie stellt Autostart-Informationen verständlich dar und hilft Dir, die Herkunft und den Zustand der gefundenen Einträge besser einzuordnen.

Dabei geht es nicht darum, möglichst viele Programme abzuschalten oder beliebige Registry-Einträge zu entfernen.

Wichtiger ist, zu verstehen, welche Programme automatisch starten und welche Funktionen Du tatsächlich benötigst.

Autostart-Einträge besser einordnen

Die Autostart-Ansicht hilft unter anderem dabei:

• benutzerbezogene und systemweite Autostarts zu unterscheiden,
• die Herkunft eines Eintrags zu erkennen,
• aktivierte und deaktivierte Einträge einzuordnen,
• und ungewöhnliche Startkonfigurationen genauer zu untersuchen.

Ein deaktiviertes Programm wird dabei nicht automatisch zu einem Fehler.

Auch ein zurückgebliebener Statuswert ist nicht zwangsläufig problematisch.

Was ist bei einer Bereinigung zu beachten?

Wenn Du einen tatsächlich verwaisten Eintrag bereinigen möchtest, solltest Du darauf achten, dass der betreffende Wert eindeutig identifiziert und zuvor gesichert wird.

Eine Sicherung ermöglicht gegebenenfalls die Wiederherstellung der ursprünglichen Statusinformation.

Die Bereinigung sollte außerdem immer bewusst und gezielt erfolgen.

Eine pauschale Entfernung aller auffälligen Autostarts ist nicht empfehlenswert.

Die jeweils verfügbaren Funktionen und Bedienmöglichkeiten findest Du direkt in der Windows Toolbox.

Windows Toolbox kostenlos herunterladen

Die Windows Toolbox ist kostenlos und für Windows 10 und Windows 11 erhältlich.

Sie bündelt zahlreiche Windows-Werkzeuge, Systeminformationen und Diagnosefunktionen in einer verständlichen Oberfläche.

Dabei ist sie kein automatischer Tuning-Booster und ersetzt auch keine Sicherheitssoftware.

Windows Toolbox kostenlos herunterladen

Häufige Fragen zu Windows-Autostart-Programmen

Welche Autostart-Programme darf ich deaktivieren?

Vor allem Anwendungen, die Du kennst und nach der Anmeldung nicht sofort benötigst.

Beispiele sind selten genutzte Messenger oder Spiele-Launcher.

Sicherheitssoftware und wichtige Gerätefunktionen solltest Du nicht wahllos deaktivieren.

Kann ich alle Autostart-Programme ausschalten?

Davon ist abzuraten.

Einige Programme übernehmen wichtige oder sinnvolle Aufgaben.

Ziel sollte nicht eine möglichst leere Autostart-Liste sein, sondern ein sinnvoll eingerichteter Windows-Start.

Warum bleibt ein Autostart-Eintrag nach der Deinstallation bestehen?

Möglicherweise hat das Deinstallationsprogramm nicht sämtliche Startbefehle oder Statusinformationen entfernt.

Es kann sich um einen alten Startbefehl, eine zurückgebliebene Verknüpfung oder lediglich eine harmlose Statusinformation handeln.

Sind verwaiste Autostart-Einträge gefährlich?

Eine allein zurückgebliebene StartupApproved-Statusinformation ist normalerweise harmlos.

Sie enthält selbst keinen vollständigen Startbefehl.

Eine Bereinigung ist deshalb häufig nicht notwendig.

Warum benötigt eine Bereinigung manchmal Administratorrechte?

Weil manche Registry-Einstellungen für den gesamten Computer gelten oder geschützt sind.

Windows verlangt dann gegebenenfalls eine Bestätigung über die Benutzerkontensteuerung.

Macht das Entfernen von Autostarts Windows schneller?

Wenn tatsächlich gestartete, nicht benötigte Programme deaktiviert werden, kann das die Anmeldung beschleunigen und Ressourcen sparen.

Das bloße Entfernen einer verwaisten Statusinformation bringt dagegen normalerweise keinen messbaren Geschwindigkeitsgewinn.

Warum startet ein deaktiviertes Programm trotzdem?

Das Programm verwendet möglicherweise einen weiteren Startmechanismus.

Prüfe seine eigenen Einstellungen, weitere Autostart-Einträge und gegebenenfalls die Windows-Aufgabenplanung.

Warum erscheint ein Programm mehrfach im Autostart?

Möglicherweise sind mehrere unterschiedliche Startmechanismen eingerichtet.

Zwei ähnlich benannte Einträge müssen deshalb nicht zwangsläufig identisch sein.

Prüfe die Herkunft und den gespeicherten Startbefehl.

Was kann ich tun, wenn nach einer Bereinigung Probleme auftreten?

Hast Du einen Autostart lediglich deaktiviert, kannst Du ihn im Task-Manager oder in den Windows-Einstellungen wieder aktivieren.

Wurde ein Registry-Wert entfernt, solltest Du nur eine passende und zuvor geprüfte Sicherung zur Wiederherstellung verwenden.

Wenn die Ursache unklar ist, solltest Du keine weiteren Registry-Änderungen auf Verdacht durchführen.

Gelten diese Anleitungen auch für Windows 10?

Die grundlegenden Startmechanismen und viele der beschriebenen Werkzeuge gibt es auch unter Windows 10.

Die Benutzeroberfläche kann sich jedoch unterscheiden.

Beachte außerdem, dass der reguläre Support für Windows 10 am 14. Oktober 2025 endete. Für bestimmte Geräte stehen gesonderte Programme für erweiterte Sicherheitsupdates zur Verfügung.

Fazit: Windows-Autostarts prüfen statt wahllos löschen

Zu viele automatisch gestartete Programme können die Anmeldung an Windows verzögern und anschließend unnötig Systemressourcen beanspruchen.

Für die meisten Nutzer genügt es, die Autostarts gelegentlich im Task-Manager oder in den Windows-Einstellungen zu überprüfen.

Deaktiviere Programme, die Du kennst und nicht unmittelbar benötigst.

Bei ungewöhnlichen Einträgen ist eine genauere Prüfung sinnvoll.

Dabei solltest Du besonders zwischen tatsächlichen Startbefehlen und gespeicherten Statusinformationen unterscheiden.

Ein deaktivierter Autostart ist kein Fehler. Und ein verwaister StartupApproved-Statuswert ist normalerweise harmlos.

Änderungen an der Windows-Registrierung sollten nur erfolgen, wenn die Herkunft eines Eintrags geklärt wurde und eine passende Sicherung vorhanden ist.

Wenn Du Autostarts lieber übersichtlich in einem Programm prüfen möchtest, hilft Dir unsere kostenlose Windows Toolbox.

Und falls Dein Computer auch unabhängig vom Autostart langsam ist, findest Du weitere Tipps in unserem Ratgeber „Windows-Computer wieder etwas schneller machen“.

---

Weiterführende Informationen

• Microsoft: Startanwendungen in Windows konfigurieren
• Microsoft: Run- und RunOnce-Registry-Schlüssel
• Microsoft: 32-Bit- und 64-Bit-Registry-Ansichten
• Microsoft: Win32_StartupCommand