Tu primer parche: por dónde empezar y qué no hacer
El salto de leer el kernel a contribuir a él. Por dónde empezar de verdad en 2026: arreglos pequeños pero reales, checkpatch --strict, el proyecto kernelnewbies y su tutorial First Kernel Patch, los programas de mentoría LFX y Outreachy. Qué NO hacer: churn de espacios en blanco, parches de LLM sin comprender, top-posting, enviar a Linus. Y qué se siente al ver tu código entrar en el kernel de miles de millones de dispositivos.
Sabes preparar un parche, encontrar a quién enviarlo, sobrevivir a la revisión y firmar las etiquetas. Solo falta lo más difícil de todo: empezar. El primer parche no es un problema técnico —para eso ya estás sobradamente preparado— sino un problema de coraje y de criterio. ¿Qué arreglo es lo bastante pequeño para no ahogarte y lo bastante real para merecer el tiempo de un mantenedor? ¿Cómo evitas los errores que marcan al novato antes de que lea tu código? Esta lección es el mapa desde el borde del agua hasta tu nombre en git log.
- Elegir un primer arreglo pequeño pero real, no un cambio trivial de ruido.
- Usar
checkpatch --stricty los avisos de las herramientas como cantera de tareas. - Conocer kernelnewbies, First Kernel Patch y los programas de mentoría de 2026.
- Saber qué no hacer, incluido el envío de parches de LLM sin comprensión.
Por dónde empezar de verdad
El mejor primer parche resuelve un problema real, aunque sea diminuto: una fuga en una ruta de error poco transitada, un valor de retorno mal comprobado, un aviso de sparse o smatch (nivel 9.2). Esos cambios enseñan el proceso completo sin exponerte a una revisión brutal, y aportan valor de verdad. Las herramientas mismas te dan la lista de tareas:
# el modo estricto encuentra más de lo que exige el mínimo
scripts/checkpatch.pl --strict --file drivers/staging/*/*.c
# los analizadores señalan bugs reales por arreglar
make C=1 drivers/misc/ # sparse
make CHECK=smatch C=1 drivers/misc/
# busca patrones a corregir con coccinelle
make coccicheck MODE=report
El punto de entrada canónico es el proyecto kernelnewbies.org y su tutorial First Kernel Patch, que te lleva paso a paso desde clonar el árbol hasta enviar. Su lista de correo existe para preguntas de principiante sin miedo al ridículo. Y en 2026 hay caminos con mentor y a veces con estipendio:
LFX Mentorship
El programa de la Linux Foundation empareja a novatos con mantenedores durante unos meses, con proyectos concretos y remunerados. La vía más sólida para pasar del primer parche a contribuir de forma sostenida.
Outreachy
Pasantías remuneradas orientadas a personas de grupos infrarrepresentados en el software libre; el kernel participa con regularidad y muchos mantenedores actuales entraron por ahí.
kernelnewbies
Comunidad, wiki y lista de correo de baja presión donde aprender el proceso y encontrar tu primera tarea sin sentirte un intruso.
Dónde encontrar tu tarea
Saber que debes empezar pequeño no te dice dónde mirar. El kernel deja pistas de trabajo pendiente por todas partes; basta con aprender a leerlas:
# comentarios que confiesan deuda técnica
git grep -n -E 'FIXME|TODO|XXX' drivers/misc/
# los avisos de las herramientas son bugs esperando dueño
scripts/checkpatch.pl --strict --file drivers/misc/midriver.c
make coccicheck MODE=report M=drivers/misc/
Más allá del árbol, tres fuentes alimentan a los recién llegados. El panel de syzbot (syzkaller.appspot.com) publica miles de fallos reproducibles hallados por fuzzing, muchos sencillos y sin dueño. El Bugzilla del kernel (bugzilla.kernel.org) recoge reportes de usuarios reales. Y la lista de kernelnewbies mantiene tareas marcadas para principiantes. Elige un bug con reproductor, entiéndelo a fondo, y ya tienes tu primer parche con un Reported-by y un Closes: listos para el pie del commit (nivel 56.4).
Qué NO hacer
Casi todos los primeros parches se rechazan por errores de forma, no de código. Evítalos y ya estarás por delante de la mayoría:
- No mandes ruido puro. Un parche que solo corrige espacios en blanco o reordena líneas en código central rompe el
git blame, genera churn y no aporta valor. Corrige estilo solo cuando ya tocas ese código por otro motivo real. - No envíes parches de un LLM que no entiendes. En 2026 los mantenedores reciben una avalancha de slop generado por modelos: parches plausibles, a menudo sutilmente rotos, de alguien que no sabe defender ni una línea. Varios subsistemas los rechazan de plano. Usa las herramientas que quieras para aprender, pero entiende cada línea que firmas: tu
Signed-off-byafirma que respondes por ese código. - No mezcles asuntos en un commit ni envíes una serie de veinte parches como primer contacto.
- No hagas top-posting, ni HTML, ni adjuntos (niveles 56.2 y 56.3).
- No envíes solo a Linus ni a la lista equivocada: corre
get_maintainer.pl. - No discutas a la defensiva ni reenvíes cada media hora. Paciencia.
Los mantenedores viven hoy una avalancha sin precedentes: parches y reportes de bugs generados por modelos de lenguaje que suenan competentes y a menudo están sutilmente rotos, enviados por gente que no puede defender ni una sola línea. Varios subsistemas y proyectos vecinos (el caso célebre fue curl) ya los rechazan de plano y penalizan al remitente reincidente. La herramienta no es el problema; la falta de comprensión sí. Si usas un modelo para aprender o esbozar, perfecto, pero entiende, prueba y sabe defender cada línea antes de firmarla: tu Signed-off-by (nivel 56.4) afirma que respondes por ese código, y un revisor detecta en dos preguntas a quien no lo entiende.
Todo lo que necesitas está escrito y es de lectura obligatoria: Documentation/process/ es el manual de la casa. Empieza por howto.rst, sigue con submitting-patches.rst y submit-checklist.rst, y ojea la serie numerada de 1.Intro.rst a 8.Conclusion.rst. Media hora ahí te ahorra el 90% de los rechazos de novato y te enseña la cultura antes de pisarla. Nadie espera que memorices el kernel; todos esperan que hayas leído el proceso.
Un recorrido de punta a punta
Todo el nivel 56 cabe en una secuencia que ejecutarás la primera vez con el corazón acelerado:
git switch -c primer-parche v6.12
$EDITOR drivers/misc/midriver.c # el arreglo, pequeño y real
git add -p && git commit -s # commit atómico y firmado (56.1)
scripts/checkpatch.pl --strict $(git format-patch -1) # limpio (9.2)
scripts/get_maintainer.pl 0001-*.patch # a quién enviar (56.2)
git send-email --to=... --cc=... 0001-*.patch
# ... llega el feedback: iteras a v2, v3 (56.3), recoges Reviewed-by ...
# ... y un día en la bandeja: "Applied, thanks" ...
No hay atajo que salte pasos, porque cada uno protege al siguiente: un commit sucio muere en checkpatch, el destinatario equivocado muere en el silencio, una respuesta soberbia muere en la indiferencia del mantenedor. Haz los cinco con humildad y paciencia y el sistema —diseñado para filtrar exactamente lo contrario— te dejará pasar.
Imagina el momento. Tras semanas de iteración, un mantenedor responde con dos palabras —“Applied, thanks”— y tu parche entra en su árbol. Unas semanas después, cuando se abra la ventana de fusión, viajará al árbol de Linus; y cuando salga la siguiente versión estable, tu código empezará a ejecutarse. Detente a medir la magnitud de eso, porque no tiene igual en ninguna otra disciplina de la ingeniería. Linux corre en los más de tres mil millones de teléfonos Android del mundo, en la abrumadora mayoría de los servidores que sostienen internet, en los quinientos superordenadores más potentes del planeta sin excepción, en coches, televisores, routers, marcapasos, sondas espaciales; incluso voló en el helicóptero Ingenuity sobre la superficie de Marte. Tu parche —esas pocas líneas que corregiste, defendiste en la lista y firmaste con tu nombre legal— pasará a formar parte de esa infraestructura invisible sobre la que descansa la civilización digital. Se ejecutará, literalmente, miles de millones de veces por segundo en dispositivos que nunca verás, de personas que jamás sabrán tu nombre. Y sin embargo tu nombre estará ahí, para siempre, en git log: git log --author="tu nombre" lo mostrará dentro de cincuenta años, cuando el hardware de hoy sea chatarra y tú ya no estés. Contribuir al kernel es una de las formas más puras que existen de dejar una marca duradera en el mundo material a través de puro pensamiento: convertiste un razonamiento, una noche de depuración, una discusión paciente por correo, en una porción permanente de la máquina más desplegada de la historia humana. El primer parche es pequeño a propósito. Su tamaño no mide su significado. Mide el ancho de la puerta por la que acabas de cruzar.
- Clona el árbol correcto (mainline o el
-nextdel subsistema que te interese) y compílalo entero al menos una vez. - Corre
scripts/checkpatch.pl --strictymake C=1sobre un driver y anota tres problemas reales candidatos a un primer parche. - Lee
Documentation/process/howto.rstysubmitting-patches.rstde principio a fin; resume en cinco puntos la etiqueta de la lista. - Prepara un arreglo pequeño y real siguiendo todo el nivel 56: commit firmado,
format-patch,get_maintainer.pl, envío porgit send-emailob4. - Cuando lo acepten, ejecuta
git log --author="tu nombre"en el árbol y quédate mirando la línea. Te la ganaste.