@@ -927,7 +927,7 @@ builtin_compile_impl(PyObject *module, PyObject *source, PyObject *filename,
                 _PyArena_Free(arena);
                 goto error;
             }
-            int syntax_check_only = ((flags & PyCF_OPTIMIZED_AST) == PyCF_ONLY_AST); /* unoptiomized AST */
+            int syntax_check_only = ((flags & PyCF_OPTIMIZED_AST) == PyCF_ONLY_AST); /* unoptimized AST */
             if (_PyCompile_AstPreprocess(mod, filename, &cf, optimize, arena,
                                          syntax_check_only, modname) < 0)
             {

@@ -814,7 +814,7 @@ _PyPickle_GetXIData(PyThreadState *tstate, PyObject *obj, _PyXIData_t *xidata)
         return -1;
     }
 
-    // If we had an "unwrapper" mechnanism, we could call
+    // If we had an "unwrapper" mechanism, we could call
     // _PyObject_GetXIData() on the bytes object directly and add
     // a simple unwrapper to call pickle.loads() on the bytes.
     size_t size = sizeof(struct _shared_pickle_data);

diff --git a/Python/emscripten_syscalls.c b/Python/emscripten_syscalls.c
@@ -25,7 +25,7 @@ int __syscall_getuid32(void) {
 
 // Emscripten's syscall layer tracks the umask in SYSCALLS.currentUmask and
 // applies it itself when creating files and directories. We mount the real
-// filesystem via NODEFS, which applies proces.umask() to everything as well. To
+// filesystem via NODEFS, which applies process.umask() to everything as well. To
 // avoid masking the mode twice, read and zero out process umask at startup,
 // and store it as emscripten's umask.
 EM_JS(void, __syscall_init_umask_js, (void), {

diff --git a/Python/errors.c b/Python/errors.c
@@ -262,7 +262,7 @@ _PyErr_SetKeyError(PyObject *arg)
 
     // PyObject_CallOneArg() must not be called with an exception set,
     // otherwise _Py_CheckFunctionResult() can fail if the function returned
-    // a result with an excception set.
+    // a result with an exception set.
     _PyErr_Clear(tstate);
 
     PyObject *exc = PyObject_CallOneArg(PyExc_KeyError, arg);

diff --git a/Python/lock.c b/Python/lock.c
@@ -120,7 +120,7 @@ _PyMutex_LockTimed(PyMutex *m, PyTime_t timeout, _PyLockFlags flags)
             // thread state (_PY_LOCK_PYTHONLOCK), the finalization thread is
             // running this code, and no other thread can unlock.
             // Raise rather than hang. (_PY_LOCK_PYTHONLOCK allows raising
-            // exceptons.)
+            // exceptions.)
             PyErr_SetString(PyExc_PythonFinalizationError,
                             "cannot acquire lock at interpreter finalization");
             return PY_LOCK_FAILURE;

@@ -612,7 +612,7 @@ optimize_uops(
         this_instr = &trace[i];
         if (ctx->done) {
             // Don't do any more optimization, but
-            // we still need to reach a terminator for corrctness.
+            // we still need to reach a terminator for correctness.
             *(ctx->out_buffer.next++) = *this_instr;
             if (is_terminator_uop(this_instr)) {
                 break;

@@ -504,7 +504,7 @@ static inline int check_interpreter_whence(long);
    For subinterpreters we memcpy() the main interpreter in
    PyInterpreterState_New(), leaving it in the same mostly-initialized
    state.  The only difference is that the interpreter has some
-   self-referential state that is statically initializexd to the
+   self-referential state that is statically initialized to the
    main interpreter.  We fix those fields here, in addition
    to the other dynamically initialized fields.
   */
@@ -566,7 +566,7 @@ init_interpreter(PyInterpreterState *interp,
     interp->threads.preallocated = &interp->_initial_thread;
 
     // We would call _PyObject_InitState() at this point
-    // if interp->feature_flags were alredy set.
+    // if interp->feature_flags were already set.
 
     _PyEval_InitState(interp);
     _PyGC_InitState(&interp->gc);