En Linux, los programas no acceden directamente a los dispositivos, lo hacen de una forma genérica a través del núcleo. Es el núcleo el que tiene que entenderse con los distintos dispositivos y sus respectivas configuraciones.
    Como en Linux disponemos del código fuente del núcleo, lo que haremos será recompilarlo de manera que soporte los distintos dispositivos de nuestro ordenador.
    Para hacer esto vamos a seguir los siguientes pasos:

• 1.- Obtención del código fuente
  2.- Configuración de la compilación
  3.- Opciones de la compilación
  4.- Compilación

1.- Obtención del código fuente
    El codigo fuente lo podremos encontrar en nuestra distribución, pero es posible que para hacer uso de una versión más moderna lo obtengamos de internet, o del típico CD que acompaña a las revistas. Tambien podemos usar patches, que sirven para actualizar un codigo fuente a la versión inmediatamente superior.
    Por ejemplo, para actualizar la versión 2.0.33 a la 2.0.35, habría que aplicar el patch a la versión 2.0.34, y despues el patch a la versión 2.0.35.

2.- Configuración para la compilación
    El código fuente del núcleo es bastante extenso, con lo que apreciaremos en gran medida una herramienta como make.
    El primer paso a realizar es colocarse en el directorio donde está el código fuente:

•  
  • cd /usr/src/linux

, operación que realizaremos naturalmente como usuario root.
    Si hemos hecho uso de patches deberemos hacer una limpieza total de restos de compilaciones anteriores mediante el comando make mrproper, ya que si no podriamos tener grandes problemas.
    El siguiente paso será elegir las opciones para la compilación. Hay tres formas de hacerlo:

• make config : Esta es la forma más rústica de hacerlo. La forma de hacerlo es mediante el método pregunta-respuesta, lo que quiere decir que si te confundes tendrás que volver a empezar. Para responder nos presenta las opciones [Y:sí, N:no, M:módulo, ?:ayuda].
• make menuconfig : Esta forma de hacerlo tambien es en modo texto pero con menús. Es necesario tener instalada la librería ncurses.
• make xconfig : Es el método más cómodo de todos. Funciona mediante menús en X-Window y nos permite guardar la configuración y cargarla posteriormente. Son necesarias las librerías Tk, y tener instaladas y configuradas las X-Window. La forma de ejecutarlo es en una consola de X escribir  make xconfig &  (El & es para no bloquear la consola).

3.- Opciones de la compilación
    Algunas opciones que en principio nos pueden parecer imprescindibles están deshabilitadas por defecto, o viceversa.

• Protocolo ppp: Si queremos conectarnos a internet a través de Linux, tendremos que habilitar el soporte de este protocolo en el núcleo.
• Puerto paralelo: Si vamos a usar una impresora que funcione a través del puerto paralelo, tendremos que darle soporte a este puerto en el núcleo.
• Capa de red: NO deshabilitarla. Aunque nuestra red sea de un solo ordenador, algunos programas funcionan a traves de la capa de red, por lo que podemos decir que esta es imprescindible.

4.- Compilación
     Una vez seleccionados los módulos a compilar, el siguiente paso es establecer las dependencias entre ellos, y eliminar los restos de compilaciones anteriores antes de realizar la compilación propiamente dicha:

•  
  • make dep; make clean

    Estos comandos son muy importantes, y no deben olvidarse nunca.
    Ahora ya podemos comenzar la compilación. Es un trabajo largo, y a no ser que tengamos memoria de sobra, lo mejor será que no molestemos al ordenador usando otra aplicación.
    Empezaremos con:

•  
  • make zImage

que nos dejará una imagen del núcleo comprimida en /usr/src/linux/arch/i386/boot/zImage.
    Si queremos instalar el núcleo en un diskette:

•  
  • make zdisk

el disquette debe estar en /dev/fd0 (en DOS es el disco A:). Con este disquette podemos arrancar Linux, lo cual es muy util en caso de que cometamos un error y no podamos arrancar de otra forma.

5.- Instalación del nuevo núcleo
    Antes de nada debemos tomar la imagen del núcleo y ponerla en su sitio, en el raíz, y la llamaremos minucleo.

• cp /usr/src/linux/arch/i386/boot/zImage /minucleo

    Ahora debemos configurar el arranque para que LILO carge el nuevo núcleo. Para ello modificaremos el archivo de configuración de LILO (etc/lilo.conf) y le diremos a LILO que lo lea.
    Para ello sustituiremos la línea image = /vmlinuz por image = /minucleo .
    Para que se lo "trage" ejecutar:

• /sbin/lilo

6.- Instalación de los módulos
    Hasta ahora hemos conseguido instalar la imagen del núcleo. Pero para instalar los módulos deberemos hacer lo siguiente:

• make modules

    Esto compilará los módulos que hemos seleccionado, y los deja dentro del arbol de directorios de las fuentes. Hay que copiar  los módulos creados y sus dependencias a /lib/modules/<version_del_nucleo>, que es donde los buscarán las herramientas que realizan la carga y descarga en el núcleo. Esto se consigue con:

• make modules_install

    La carga manual se realiza con las herramientas modprobe y depmod. Antes de cargar un módulo, hay que cargar la tabla de dependencias con:

• /sbin/depmod -a

    Despues podemos cargar un módulo en el núcleo con:

• /sbin/modprobe <módulo>

que cargará el módulo indicado, y todos aquellos de los que depende. Hay que tener en cuenta que cada vez que se instale un nuevo núcleo habra que compilar e instalar los módulos.
    Para que la carga y descarga de los módulos se realice de forma automática, usaremos kerneld. Al arrancar ejecutaremos:

• /sbin/modprobe -a
  /sbin/kerneld

esta forma de hacerlo tiene la ventaja de que los módulos sólo se cargan cuando se necesitan, y se descargan cuando no son necesarios, lo que implica un ahorro de memoria.