> ## Content Index
> Fetch the complete content index at: https://arabroot.io/llms.txt
> Use this file to discover other available public pages before exploring further.

# WSL2 للمطورين: كيف يعمل Linux داخل Windows
- URL: https://arabroot.io/articles/wsl2-للمطورين-كيف-يعمل-linux-داخل-windows/
- Published: 2026-11-12T18:58:43.000Z
- Updated: 2026-11-16T11:46:47.000Z
- Description: ما الذي يعمل تحت WSL 2 من آلة افتراضية ونواة Linux وشبكة ونظامي ملفات، ولماذا يبطئ مشروعك على قرص C مئة مرة، مع مختبر قسنا فيه الملفات وDocker والشبكة على Windows 11.
- Author: فريق عرب رووت
- Tags: الأدلة التقنية, Windows للمسؤولين والمطورين

أغلب المطورين في شركاتنا يكتبون الكود على جهاز Windows، بينما يعمل الكود نفسه في النهاية على سيرفر Linux، وبين الجهتين تظهر المشاكل الصغيرة التي تأكل اليوم: سكربت `deploy.sh` الذي كتبه زميلك لا يعمل في PowerShell، و`Makefile` المشروع يفترض وجود `bash` و`sed` و`grep`، ومكتبة Python تحتاج مترجماً لا يوجد إلا في Linux، وملف Dockerfile تريد أن تجربه قبل أن ترفعه، والخطأ الذي يظهر على السيرفر بسبب حالة الأحرف في اسم ملف لا يظهر عندك أبداً. وكان الحل لسنوات إما أن تقسم القرص وتقلع Linux بجانب Windows، أو أن تشغل آلة افتراضية كاملة في VirtualBox وتنقل الملفات بينها وبين جهازك، أو أن تكتفي بأدوات مثل Git Bash التي تحاكي جزءاً من بيئة Linux دون أن تكون Linux.

ونظام Windows Subsystem for Linux واختصاراً WSL هو جواب Microsoft على هذه المشكلة: توزيعة Linux حقيقية مثل Ubuntu أو Debian تعمل داخل Windows، تفتحها من الطرفية Terminal في ثانية، وترى منها ملفات Windows، وتشغل منها برامج Windows، ويصل متصفحك في Windows إلى السيرفر الذي تشغله فيها عبر `localhost`. لكن هذه السهولة تخفي خلفها آلة افتراضية Virtual Machine وشبكة خاصة ونظامي ملفات مختلفين، ومن لا يعرف ما تحت السطح يقع في أخطاء تكلفه ساعات: مشروع يبني في دقيقة بدل ثوان، وسيرفر في Windows لا يصل إليه الكود في Linux، وذاكرة يحجزها WSL ولا يعرف المطور لماذا.

وهذا المقال من مسار Windows للمسؤولين والمطورين، وقبله [مقال كيف يعمل Windows من الداخل](https://arabroot.io/articles/%D9%83%D9%8A%D9%81-%D9%8A%D8%B9%D9%85%D9%84-windows-%D9%85%D9%86-%D8%A7%D9%84%D8%AF%D8%A7%D8%AE%D9%84-%D9%88%D8%B6%D8%B9-%D8%A7%D9%84%D9%85%D8%B3%D8%AA%D8%AE%D8%AF%D9%85-%D9%88%D8%A7%D9%84%D9%86%D9%88%D8%A7%D8%A9/) الذي شرح وضع المستخدم ووضع النواة واستدعاءات النظام، وهذه المفاهيم هي التي سوف نبني عليها هنا. وسوف نتناول في هذا المقال ما يلي:

- الخيارات التي كانت أمام المطور قبل WSL، ولماذا حل كل منها جزءاً من المشكلة وترك جزءاً.
- WSL 1 الذي يترجم استدعاءات Linux، وWSL 2 الذي يشغل نواة Linux حقيقية في VM خفيفة، والفرق العملي بينهما.
- المختبر: ننظر داخل WSL 2 على جهاز Windows 11 حقيقي، ونقيس الفرق بين ملفات المشروع على ext4 وعلى قرص C.
- Docker Desktop وكيف يستعمل WSL 2، ولماذا يبطئ ربط مجلد من Windows داخل الـ Container.
- الشبكة في الوضع NAT والوضع Mirrored، ولماذا يصل Windows إلى Linux ولا يصل Linux إلى Windows عبر `localhost`.
- الذاكرة والمعالج وملفا `.wslconfig` و`wsl.conf`، وsystemd، وتشغيل برامج Windows من Linux.
- الأخطاء الشائعة، وتطبيق عملي، والخلاصة.

## ماذا كان أمام المطور قبل WSL؟

قبل أن نشرح WSL نحتاج أن نرى الخيارات التي كانت موجودة، لأن كل خيار منها حل جزءاً من المشكلة وترك جزءاً، وWSL نفسه في نسختيه حاول أن يجمع مزاياها ويتجنب عيوبها.

الخيار الأول هو الإقلاع المزدوج Dual Boot: تقسم القرص وتثبت Linux بجانب Windows، وعند تشغيل الجهاز تختار أحدهما. وهذا يعطيك Linux كاملاً بأداء العتاد نفسه، لكنك لا تستطيع أن تستعمل النظامين في الوقت نفسه، فإذا كنت في Linux وأردت أن تفتح ملف Excel أو اجتماع Teams فعليك أن تعيد التشغيل، وبالتالي يتحول الأمر في أغلب الحالات إلى نظام تستعمله وآخر تنساه.

الخيار الثاني هو الآلة الافتراضية Virtual Machine في VirtualBox أو VMware أو Hyper-V، وقد شرحنا فكرتها في [مقال المحاكاة الافتراضية Virtualization](https://arabroot.io/articles/%D9%85%D8%A7-%D9%87%D9%8A-%D8%A7%D9%84%D9%85%D8%AD%D8%A7%D9%83%D8%A7%D8%A9-%D8%A7%D9%84%D8%A7%D9%81%D8%AA%D8%B1%D8%A7%D8%B6%D9%8A%D8%A9-virtualization-%D9%85%D9%86-hypervisor-%D8%A7%D9%84%D9%89-kvm/). وهنا يعمل النظامان معاً، لكن الآلة الافتراضية جهاز منفصل تديره بنفسك: تحدد لها الذاكرة مسبقاً فتحجزها حتى لو لم تستعملها، وتقلع في دقيقة، ولها عنوان IP آخر، ونقل الملفات بينها وبين Windows يحتاج مجلداً مشتركاً أو SSH، وكل هذا يجعل المطور يستعملها عند الحاجة فقط.

الخيار الثالث هو المحاكاة على مستوى الأدوات، مثل Cygwin وMSYS2 وGit Bash الذي يأتي مع Git على Windows. وهذه برامج Windows عادية أعيدت كتابتها لتتصرف مثل أدوات Linux، فتكتب `ls` و`grep` وتعمل، لكنها ليست Linux: لا تستطيع أن تشغل ملفاً تنفيذياً مبنياً لـ Linux، ولا Docker، ولا مكتبة تعتمد على استدعاءات نظام خاصة بـ Linux، وسلوكها في الصلاحيات ومسارات الملفات يختلف عن السيرفر الذي سوف يعمل عليه الكود.

والخيار الرابع هو أن تعمل مباشرة على سيرفر Linux عن بعد عبر SSH، وهو حل جيد لمن لديه سيرفر قريب واتصال ثابت، لكنه يربط عملك بالشبكة ويضيف تأخيراً لكل أمر تكتبه. ولذلك بقي السؤال مفتوحاً: كيف تحصل على Linux حقيقي يعمل مع Windows في الوقت نفسه، دون أن تدير آلة افتراضية، ودون أن تدفع ثمن الأداء؟

## WSL 1: Windows يتعلم أن يتكلم لغة Linux

أعلنت Microsoft عن WSL في مؤتمر Build سنة 2016، ووصل إلى المستخدمين مع تحديث Windows 10 Anniversary Update في السنة نفسها، والفكرة كانت جريئة: بدل أن تشغل نواة Linux، تجعل نواة Windows نفسها تفهم البرامج المكتوبة لـ Linux. وكما شرحنا في [مقال فضاء النواة وفضاء المستخدم](https://arabroot.io/articles/%D9%81%D8%B6%D8%A7%D8%A1-%D8%A7%D9%84%D9%86%D9%88%D8%A7%D8%A9-%D9%88%D9%81%D8%B6%D8%A7%D8%A1-%D8%A7%D9%84%D9%85%D8%B3%D8%AA%D8%AE%D8%AF%D9%85-%D9%88%D8%A7%D8%B3%D8%AA%D8%AF%D8%B9%D8%A7%D8%A1%D8%A7%D8%AA-%D8%A7%D9%84%D9%86%D8%B8%D8%A7%D9%85/) فإن أي برنامج في Linux يطلب ما يحتاجه من النواة عبر استدعاءات النظام System Calls: افتح هذا الملف، اكتب في هذا الـ Socket، أنشئ عملية جديدة. فإذا وجدت طبقة داخل نواة Windows تستقبل هذه الاستدعاءات وتنفذ ما يقابلها في Windows، فسوف يعمل برنامج Linux الأصلي بصيغة ELF كما هو، دون إعادة بناء.

وهذا ما فعله تعريف اسمه `lxcore.sys`، وهو بحسب [مدونة Windows للمطورين](https://blogs.windows.com/windowsdeveloper/2025/05/19/the-windows-subsystem-for-linux-is-now-open-source/?ref=arabroot.io) مزود عمليات من نوع Pico Process Provider يعمل داخل نواة Windows، ويشغل ملفات ELF مباشرة، وينفذ استدعاءات Linux داخل النواة. فعندما يطلب `bash` فتح ملف، يستقبل `lxcore.sys` الطلب ويحوله إلى عملية فتح ملف على NTFS، وعندما يطلب `node` فتح Socket يحوله إلى ما يقابله في شبكة Windows، والصورة التالية تبين الفرق بين هذا الأسلوب وأسلوب WSL 2:

![رسم من جزأين: على اليمين WSL 1 منذ 2016، فيه برنامج Linux مثل bash وnode وgit وبرنامج Windows مثل notepad.exe، وكلاهما ينزل إلى نواة Windows ntoskrnl.exe، وداخلها lxcore.sys الذي يترجم كل استدعاء إلى ما يقابله في Windows بجانب NTFS وTCP/IP، ثم العتاد، وتحتها عبارة ترجمة ناقصة بعض الاستدعاءات غير مدعومة ولذلك لم يعمل Docker داخله. وعلى اليسار WSL 2 منذ 2019، فيه lightweight utility VM داخلها توزيعتا Ubuntu وdocker-desktop فوق Linux kernel 5.15، وبجانبها برامج Windows فوق نواة Windows، وكل ذلك فوق Hyper-V platform ثم العتاد، وتحتها عبارة كل التوزيعات تشترك في VM واحدة ونواة واحدة](https://arabroot.io/content/images/2026/11/wsl2-for-developers-01-wsl1-wsl2.webp)

WSL 1 يترجم الاستدعاءات داخل نواة Windows، وWSL 2 يرسلها إلى نواة Linux حقيقية تعمل في آلة افتراضية خفيفة تديرها Windows بنفسها.

وللترجمة ميزة واضحة: ملفات Linux هي ملفات NTFS نفسها، والشبكة هي شبكة Windows نفسها، ولا توجد آلة افتراضية تحجز ذاكرة. لكن للترجمة مشكلة رئيسية لم تحل: نواة Linux فيها مئات الاستدعاءات، ولكل منها تفاصيل وحالات خاصة تعتمد عليها البرامج، وفريق WSL كان يطارد هذه التفاصيل واحداً بعد الآخر. وبالتالي كانت البرامج البسيطة تعمل، بينما البرامج التي تعتمد على خصائص عميقة في النواة مثل Docker، الذي يحتاج cgroups وnamespaces وأنظمة ملفات من نوع overlay، لم تعمل أبداً على WSL 1\. وكان أداء الملفات بطيئاً في الأعمال التي تفتح آلاف الملفات الصغيرة مثل `git` و`npm install`، لأن كل عملية فتح ملف تمر بطبقة الترجمة ثم بكل ما يمر به أي ملف في Windows.

## WSL 2: نواة Linux حقيقية في آلة افتراضية لا تراها

في 6 مايو 2019 [أعلن فريق WSL عن WSL 2](https://devblogs.microsoft.com/commandline/announcing-wsl-2/?ref=arabroot.io) بمعمارية مختلفة تماماً: بدل الترجمة، تشحن Microsoft نواة Linux حقيقية مع Windows لأول مرة، مبنية من الفرع المستقر في kernel.org، وبدأت بالإصدار 4.19، وتعمل هذه النواة داخل آلة افتراضية. وقد يتساءل البعض: إذا كان الحل في النهاية آلة افتراضية، فما الذي تغير عن VirtualBox؟ والإجابة على ذلك أن هذه الآلة الافتراضية ليست آلتك أنت، وإنما هي بحسب [توثيق Microsoft](https://learn.microsoft.com/en-us/windows/wsl/compare-versions?ref=arabroot.io) آلة افتراضية خفيفة للخدمة Lightweight Utility VM تديرها Windows بنفسها: تقلع في ثانية أو ثانيتين عند أول أمر، وتأخذ من الذاكرة ما تحتاجه فقط حتى سقف محدد، وتتوقف وحدها إذا لم تستعملها، وتعمل على منصة Hyper-V نفسها لكنك لا تراها في Hyper-V Manager ولا تحتاج أن تفتحه.

والنقطة الثانية المهمة أن كل التوزيعات التي تثبتها تعمل داخل الآلة الافتراضية نفسها. فإذا ثبت Ubuntu وDebian، وثبت معهما Docker Desktop الذي يضيف توزيعته الخاصة `docker-desktop`، فلن تجد ثلاث آلات افتراضية، وإنما آلة واحدة ونواة واحدة، وكل توزيعة تعمل فيها معزولة كأنها Container. وبحسب [صفحة التعريف بـ WSL](https://learn.microsoft.com/en-us/windows/wsl/about?ref=arabroot.io) تشترك التوزيعات في الشبكة نفسها Network Namespace والمعالج والنواة والذاكرة والـ Swap، ولكل توزيعة مساحة عمليات PID Namespace خاصة بها ونظام ملفات ومستخدمون وعملية `init` خاصة بها. وهذا يفسر أشياء سوف نراها في المختبر: الذاكرة التي تراها في Ubuntu هي نفسها التي يراها Docker، والمنفذ Port الذي يفتحه برنامج في توزيعة يتعارض مع منفذ في توزيعة أخرى.

والجدول التالي يلخص الفرق بين النسختين كما في [صفحة المقارنة الرسمية](https://learn.microsoft.com/en-us/windows/wsl/compare-versions?ref=arabroot.io):

| الخاصية                                            | WSL 1          | WSL 2                  |
| -------------------------------------------------- | -------------- | ---------------------- |
| نواة Linux كاملة                                   | لا، طبقة ترجمة | نعم                    |
| توافق كامل مع استدعاءات النظام                     | لا             | نعم، ولذلك يعمل Docker |
| systemd                                            | لا             | نعم                    |
| أداء الملفات داخل Linux                            | أبطأ           | أسرع بكثير             |
| أداء الملفات عبر النظامين (ملفات Windows من Linux) | أفضل           | أبطأ                   |
| يعمل مع إصدارات VMware وVirtualBox الحالية         | نعم            | نعم                    |

لاحظ السطر الخامس، فهو الثمن الذي دفعه WSL 2 مقابل النواة الحقيقية، وهو أهم سطر في هذا المقال بالنسبة للمطور، وسوف نقيسه بالأرقام في المختبر. وتذكر أيضاً أن WSL 2 هو الافتراضي اليوم عند تثبيت أي توزيعة، وأن الأمر `wsl --set-version` يسمح لك بتحويل توزيعة بين النسختين إذا احتجت WSL 1 لسبب خاص.

📌

في 19 مايو 2025 نشرت Microsoft الكود المصدري لـ WSL على GitHub، وأغلقت بذلك أول طلب فتح في مستودع المشروع قبل سنوات يسأل هل سيصبح مفتوح المصدر. وبقيت ثلاثة أجزاء داخل Windows لم يفتح مصدرها: `lxcore.sys` الذي يشغل WSL 1، و`p9rdr.sys` و`p9np.dll` اللذان يشغلان المسار `\\wsl.localhost` الذي تفتح منه ملفات Linux في Windows، كما في [إعلان المدونة](https://blogs.windows.com/windowsdeveloper/2025/05/19/the-windows-subsystem-for-linux-is-now-open-source/?ref=arabroot.io).

## المختبر: ماذا يوجد داخل WSL 2 على جهاز حقيقي؟

الآن سوف ننتقل من الكلام إلى الجهاز. المختبر سكربت PowerShell واحد اسمه `run.ps1` يعمل على Windows 10 أو 11 بعد تثبيت WSL، ولا يحتاج صلاحيات المسؤول، ولا يثبت شيئاً ولا يغير أي إعداد: يقرأ حالة WSL، ويشغل قياسات في مجلدات ينشئها ثم يحذفها، ويفتح ثلاثة منافذ لثوان. وإذا لم يكن WSL مثبتاً عندك فالأمر الذي يثبته مع Ubuntu هو أمر واحد من PowerShell بصلاحيات المسؤول:

```powershell
wsl --install                     # WSL مع Ubuntu، ثم أعد تشغيل الجهاز
wsl --list --online               # التوزيعات المتاحة للتثبيت
wsl --install -d Debian           # توزيعة أخرى بالاسم
```

ثم نشغل المختبر من مجلده، والقسم الأول منه يطبع إصدار WSL والتوزيعات المثبتة ومواصفات الجهاز:

```powershell
cd lab
powershell -ExecutionPolicy Bypass -File run.ps1               # التوزيعة الافتراضية
powershell -ExecutionPolicy Bypass -File run.ps1 -Distro Ubuntu
```

والمخرج سوف يكون كما يلي:

```text
### wsl --version
WSL version: 2.4.11.0
Kernel version: 5.15.167.4-1
WSLg version: 1.0.65
MSRDC version: 1.2.5716
Direct3D version: 1.611.1-81528511
DXCore version: 10.0.26100.1-240331-1435.ge-release
Windows version: 10.0.26100.9711
### wsl -l -v
  NAME              STATE           VERSION
* docker-desktop    Running         2
### wsl --status
Default Distribution: docker-desktop
Default Version: 2
### this Windows machine
8 logical CPUs, 63.9 GB RAM, .wslconfig present: False
```

في المخرج أعلاه لاحظ التالي:

- الإصدار 2.4.11 هو إصدار حزمة WSL نفسها التي تحدثها من Microsoft Store أو بالأمر `wsl --update`، والنواة 5.15.167.4 تأتي معها، أي أن نواة Linux عندك لا تنتظر تحديث Windows الكبير وإنما تتحدث مع WSL.
- التوزيعة الوحيدة على هذا الجهاز هي `docker-desktop`، وهي التوزيعة التي يضيفها Docker Desktop عند تثبيته ليشغل فيها محرك Docker. وأغلب أجهزة المطورين سوف تجد فيها Ubuntu بجانبها، وكل ما سوف نقيسه هنا يعمل بالطريقة نفسها في Ubuntu، لأن التوزيعات كلها تعمل في الآلة الافتراضية نفسها، والفرق الوحيد سوف نشير إليه في مكانه: المسار الذي تظهر فيه أقراص Windows.
- الجهاز فيه 8 معالجات منطقية و63.9 GB من الذاكرة، ولا يوجد ملف `.wslconfig`، أي أن WSL يعمل بإعداداته الافتراضية، وتذكر هذين الرقمين لأننا سوف نراهما من داخل Linux بعد قليل.

### من داخل التوزيعة

القسم الثاني من المختبر يشغل سكربت `sh` صغيراً داخل التوزيعة، وهو مكتوب بأوامر POSIX فقط حتى يعمل في أي توزيعة، حتى في `docker-desktop` التي لا تحتوي إلا على BusyBox:

```bash
#!/bin/sh
# What a WSL 2 distribution sees from the inside:  sh inside.sh
echo "kernel:     $(uname -r)"
echo "machine:    $(uname -m), $(nproc) CPUs"
echo "memory:     $(awk '/MemTotal/ { printf "%d MB", $2 / 1024 }' /proc/meminfo), swap $(awk '/SwapTotal/ { printf "%d MB", $2 / 1024 }' /proc/meminfo)"
echo "PID 1:      $(readlink /proc/1/exe)"
echo "network:    $(wslinfo --networking-mode) mode"
echo
echo "### where the files live (from /proc/mounts)"
awk '$2 == "/" || $2 ~ /^\/mnt\/(host\/)?c$/ || $2 == "/mnt/docker-desktop-disk" || $2 == "/home" { printf "%-28s %-6s %s\n", $2, $3, $1 }' /proc/mounts | sort -u
echo
echo "### /etc/wsl.conf"
cat /etc/wsl.conf 2>/dev/null || echo "(none)"
```

وفي PowerShell نشغله بالأمر `wsl -d <distro> -e sh inside.sh`، ثم نشغل Container من Docker ونطلب منه إصدار النواة وعدد المعالجات، والمخرج سوف يكون كما يلي:

```text
### inside the 'docker-desktop' distribution
kernel:     5.15.167.4-microsoft-standard-WSL2
machine:    x86_64, 8 CPUs
memory:     32036 MB, swap 8192 MB
PID 1:      /init
network:    nat mode

### where the files live (from /proc/mounts)
/                            ext4   /dev/sdc
/mnt/docker-desktop-disk     ext4   /dev/sdd
/mnt/host/c                  9p     C:\134

### /etc/wsl.conf
[automount]
root = /mnt/host
options = "metadata"
[interop]
enabled = true
### the same kernel seen from a Docker container
container kernel: 5.15.167.4-microsoft-standard-WSL2, 8 CPUs
```

في المخرج أعلاه لاحظ التالي:

- النواة `5.15.167.4-microsoft-standard-WSL2` هي نواة Linux حقيقية بنتها Microsoft، وهي نفسها التي رآها الـ Container في السطر الأخير، فالـ Container الذي يشغله Docker Desktop والتوزيعة يعملان على نواة واحدة في آلة افتراضية واحدة.
- الذاكرة داخل Linux هي 32,036 MB، أي نصف ذاكرة الجهاز تقريباً، والمعالجات 8 أي كلها، وهذا هو الإعداد الافتراضي الذي سوف نعود إليه في قسم الذاكرة.
- العملية رقم 1 هي `/init`، وهي برنامج WSL الذي يقلع التوزيعة، وليست systemd، وسوف نعود إلى هذه النقطة في قسم systemd.
- نظام الملفات الرئيسي للتوزيعة `/` من نوع ext4 على قرص `/dev/sdc`، وهذا القرص في الحقيقة ملف قرص افتراضي من نوع VHDX على قرص Windows، بينما قرص C نفسه يظهر في Linux بنوع مختلف تماماً هو `9p`، والكتابة `C:\` هي `C:` مع الشرطة المائلة مكتوبة بالنظام الثماني كما يكتبها ملف `/proc/mounts`. وهذا السطر هو مفتاح القسم القادم.
- التوزيعة `docker-desktop` تضع أقراص Windows تحت `/mnt/host/c` لأن ملف `/etc/wsl.conf` فيها يغير القيمة `root`، أما في Ubuntu وبقية التوزيعات فالافتراضي هو `/mnt/c` كما في [صفحة الإعدادات](https://learn.microsoft.com/en-us/windows/wsl/wsl-config?ref=arabroot.io)، ولذلك سوف نكتب `/mnt/c` في بقية المقال.

## أين تضع ملفات مشروعك؟ الفرق بين ext4 و/mnt/c

عندما تفتح Ubuntu في WSL وتكتب `cd /mnt/c/Users/user1/projects/api` فأنت تعمل على ملفات موجودة في NTFS على قرص Windows، وعندما تكتب `cd ~/projects/api` فأنت تعمل على ملفات موجودة في ext4 داخل القرص الافتراضي للتوزيعة. والفرق بين المسارين ليس في المكان فقط: ملفات ext4 تقرؤها نواة Linux مباشرة من قرصها، أما ملفات `/mnt/c` فلا تملكها النواة أصلاً، لأنها في نظام ملفات يديره Windows على الطرف الآخر من الآلة الافتراضية، ولذلك تصل إليها النواة عبر بروتوكول شبكة ملفات اسمه 9P: كل عملية فتح ملف أو قراءة معلوماته أو حذفه تتحول إلى رسالة تخرج من الآلة الافتراضية إلى سيرفر 9P يعمل في Windows، وهذا السيرفر ينفذ العملية على NTFS، ويمر في طريقه على كل ما يمر به أي ملف في Windows من تعريفات الفلترة Filter Drivers ومضاد الفيروسات كما شرحنا في [مقال Windows من الداخل](https://arabroot.io/articles/%D9%83%D9%8A%D9%81-%D9%8A%D8%B9%D9%85%D9%84-windows-%D9%85%D9%86-%D8%A7%D9%84%D8%AF%D8%A7%D8%AE%D9%84-%D9%88%D8%B6%D8%B9-%D8%A7%D9%84%D9%85%D8%B3%D8%AA%D8%AE%D8%AF%D9%85-%D9%88%D8%A7%D9%84%D9%86%D9%88%D8%A7%D8%A9/)، ثم يرجع الرد بالطريق نفسه.

![رسم من جزأين: في الأعلى برنامج npm install وgit status داخل Linux، ومنه سهم أخضر مباشر إلى ~/project على ext4 ثم إلى القرص الافتراضي ext4.vhdx، وسهم أحمر إلى /mnt/c وهو 9P client، ثم سهم متقطع مكتوب عليه يعبر الحدود إلى 9P server on Windows، ثم إلى C:\project على NTFS. وفي الأسفل رسم بياني لـ 5,000 ملف صغير: إنشاء الملفات 60.1 ثانية على C مقابل 0.52 ثانية على ext4، وقراءتها 22.5 مقابل 0.16، وحذفها 19.2 مقابل 0.11](https://arabroot.io/content/images/2026/11/wsl2-for-developers-02-files.webp)

الملف على ext4 تقرؤه النواة مباشرة، والملف على C يعبر إلى Windows ثم يرجع، والرسم البياني من قياس المختبر على هذا الجهاز.

والآن سوف نقيس هذا الفرق بالأرقام. السكربت التالي يعمل داخل Linux، وينشئ 5,000 ملف صغير بحجم 1 KB في 50 مجلداً، وهذا قريب مما يحدث في `node_modules` أو في مستودع كود متوسط، ثم يقرأ معلومات كل ملف كما يفعل `git status`، ثم يقرأ محتوى الملفات كلها، ثم يحذفها، وفي النهاية يكتب ملفاً واحداً كبيراً بحجم 256 MB:

```bash
#!/bin/sh
# Small-files benchmark, run INSIDE a WSL 2 distribution (plain POSIX sh, works with BusyBox):
#   sh bench.sh <dir> [dirs] [files-per-dir] [big-MB]
# Creates dirs x files small files (1 KB each, like a node_modules or a source tree), then lists them with stat,
# reads them all, deletes them, and finally writes one big file with fsync. Prints the time of each step in ms.
# Times come from /proc/uptime (10 ms resolution), which every distribution has.
D=$1; ND=${2:-50}; NF=${3:-100}; MB=${4:-256}
[ -n "$D" ] || { echo "usage: sh bench.sh <dir> [dirs] [files] [big-MB]"; exit 1; }
now() { read u _ < /proc/uptime; s=${u%.*}; f=${u#*.}; f=${f#0}; echo $(( s * 1000 + f * 10 )); }
PAY=$(printf '%01000d' 0)                     # 1,000 bytes of content per file
rm -rf "$D" "$D.big"; mkdir -p "$D"

t0=$(now)
i=0
while [ $i -lt "$ND" ]; do
  mkdir "$D/pkg$i"; j=0
  while [ $j -lt "$NF" ]; do printf '%s\n' "$PAY" > "$D/pkg$i/f$j.js"; j=$((j + 1)); done
  i=$((i + 1))
done
t1=$(now)
bytes=$(find "$D" -type f -exec stat -c %s {} + | awk '{ s += $1 } END { print s }')   # one stat per file, like git status
t2=$(now)
read_bytes=$(find "$D" -type f -exec cat {} + | wc -c)                               # open + read + close per file
t3=$(now)
rm -rf "$D"
t4=$(now)
dd if=/dev/zero of="$D.big" bs=1M count="$MB" conv=fsync 2>/dev/null                 # one big file, written to disk
t5=$(now)
rm -f "$D.big"

files=$((ND * NF))
echo "create $files files: $((t1 - t0)) ms"
echo "stat $files files ($bytes bytes): $((t2 - t1)) ms"
echo "read $files files ($read_bytes bytes): $((t3 - t2)) ms"
echo "delete $files files: $((t4 - t3)) ms"
echo "write one ${MB} MB file: $((t5 - t4)) ms"
```

ثم يشغله `run.ps1` ثلاث مرات في كل مكان، مرة في مجلد على قرص C عبر `/mnt/c`، ومرة في مجلد على قرص التوزيعة ext4، ويطبع الوسيط Median من المرات الثلاث مع كل قيمة، والمخرج سوف يكون كما يلي:

```text
### Windows drive (NTFS through 9P): /mnt/host/c/work/wsl-lab/data/bench
create 5000 files                          60100 ms   (runs: 112790, 60100, 60080)
stat 5000 files (5005000 bytes)            15560 ms   (runs: 14860, 27900, 15560)
read 5000 files (5005000 bytes)            22540 ms   (runs: 22540, 43620, 21970)
delete 5000 files                          19190 ms   (runs: 19190, 31980, 18930)
write one 256 MB file                       3670 ms   (runs: 2970, 3670, 24530)
### Linux disk (ext4 in the VHDX): /mnt/docker-desktop-disk/arabroot-wsl-bench
create 5000 files                            520 ms   (runs: 520, 670, 410)
stat 5000 files (5005000 bytes)               60 ms   (runs: 40, 60, 60)
read 5000 files (5005000 bytes)              160 ms   (runs: 110, 170, 160)
delete 5000 files                            110 ms   (runs: 110, 100, 140)
write one 256 MB file                        540 ms   (runs: 1410, 490, 540)
```

في المخرج أعلاه لاحظ التالي:

- إنشاء 5,000 ملف صغير استغرق 60.1 ثانية على قرص C و0.52 ثانية على ext4، أي أن العملية نفسها أبطأ بأكثر من 100 مرة، وقراءة الملفات 22.5 ثانية مقابل 0.16، والحذف 19.2 ثانية مقابل 0.11\. وهذه ليست أرقاماً نظرية، فهذا هو الفرق الذي تشعر به عندما يستغرق `npm install` أو `git status` أو بناء المشروع دقائق بدل ثوان.
- الملف الكبير بحجم 256 MB استغرق 3.7 ثانية على C و0.54 ثانية على ext4، والفرق هنا سبع مرات تقريباً وليس مئة مرة، والسبب أن تكلفة 9P في كل عملية وليست في كل بايت: ملف واحد كبير يعني رسائل قليلة كل منها يحمل بيانات كثيرة، بينما آلاف الملفات الصغيرة تعني آلاف الرسائل الذاهبة والراجعة. ولذلك فالمشكلة تظهر في أعمال المطورين بالذات، لأنها كلها ملفات صغيرة كثيرة.
- في القياسات الثلاث على C اختلفت المرة الأولى عن الأخريين، فقد استغرق الإنشاء 112.8 ثانية في المرة الأولى، وكتابة الملف الكبير 24.5 ثانية في المرة الثالثة، وهذا التفاوت نفسه جزء من المشكلة: كل ما يعمل في Windows في تلك اللحظة، من مضاد الفيروسات إلى الفهرسة Indexing، يؤثر على أداء `/mnt/c`، بينما بقيت أرقام ext4 ثابتة تقريباً.

وهذه المشكلة معروفة منذ بداية WSL 2، ففي 19 يونيو 2019، بعد أيام من صدور أول نسخة تجريبية، فتح أحد المطورين [الطلب 4197 في مستودع WSL](https://github.com/microsoft/WSL/issues/4197?ref=arabroot.io) بعنوان أداء نظام الملفات في `/mnt` أبطأ بكثير من WSL 1، وما زال الطلب مفتوحاً حتى اليوم وعليه أكثر من 500 تعليق وأكثر من 650 تأييداً. ولذلك فالحل ليس انتظار إصلاح، وإنما القاعدة التي تكتبها Microsoft نفسها في [صفحة أنظمة الملفات](https://learn.microsoft.com/en-us/windows/wsl/filesystems?ref=arabroot.io): إذا كنت تعمل من سطر أوامر Linux فضع ملفات المشروع في نظام ملفات Linux مثل `/home/<user>/project`، وإذا كنت تعمل من PowerShell فضعها في Windows، ولا تقم بالعمل عبر النظامين إلا لسبب محدد.

⚠️

إذا نقلت مشروعك إلى `~/` داخل Linux فلا تفتحه في محررك من `\\wsl.localhost` كأنه مجلد شبكة، لأنك سوف تنقل البطء إلى المحرر بدل الطرفية. الطريقة الصحيحة أن تفتح المحرر من داخل Linux، فالأمر `code .` داخل مجلد المشروع يفتح VS Code مع إضافة WSL، فتعمل الواجهة في Windows بينما يعمل خادم المحرر وأدوات البحث والـ Git داخل Linux بجانب الملفات.

### والاتجاه المعاكس: Windows يقرأ ملفات Linux

قد يتساءل البعض: إذا وضعت المشروع في Linux، فماذا لو احتجت أن تفتح ملفاته من برنامج Windows مثل المستكشف Explorer أو برنامج مقارنة ملفات؟ هذا ممكن عبر المسار `\\wsl.localhost\Ubuntu\home\...` أو بكتابة `explorer.exe .` داخل المجلد في Linux، لكن هذا الطريق يمر أيضاً عبر 9P في الاتجاه الآخر، والقسم الرابع من المختبر يقيسه من PowerShell بأوامر .NET مباشرة حتى لا يحسب بطء PowerShell نفسه:

```powershell
    $text = '0' * 1000
    $c = Measure-Command { for ($i = 0; $i -lt 20; $i++) { $p = Join-Path $d "pkg$i"; [IO.Directory]::CreateDirectory($p) | Out-Null; for ($j = 0; $j -lt 100; $j++) { [IO.File]::WriteAllText("$p\f$j.js", $text) } } }
    $s = Measure-Command { $n = 0; foreach ($f in [IO.Directory]::EnumerateFiles($d, '*', 'AllDirectories')) { $n += ([IO.FileInfo]$f).Length } }
    $rd = Measure-Command { foreach ($f in [IO.Directory]::EnumerateFiles($d, '*', 'AllDirectories')) { [void][IO.File]::ReadAllBytes($f) } }
    $x = Measure-Command { [IO.Directory]::Delete($d, $true) }
```

والمخرج سوف يكون كما يلي:

```text
### PowerShell, 2,000 files of 1 KB: NTFS folder on C:
create 8,101 ms | list + size 280 ms (2,000,000 bytes) | read 385 ms | delete 926 ms
### PowerShell, 2,000 files of 1 KB: Linux folder through \\wsl.localhost
create 8,033 ms | list + size 3,068 ms (2,000,000 bytes) | read 39,210 ms | delete 14,413 ms
```

في المخرج أعلاه لاحظ أن إنشاء 2,000 ملف استغرق 8 ثوان تقريباً في المكانين، وهذا رقم بطيء حتى على NTFS نفسه، لأن كل ملف جديد يفحصه مضاد الفيروسات في Windows قبل أن يكتمل إنشاؤه، وهي نقطة تستحق أن تتذكرها عندما تقارن بين أداء Windows وLinux في أعمال البناء. لكن الفرق الحقيقي ظهر في القراءة: 0.4 ثانية من NTFS مقابل 39 ثانية من مجلد Linux عبر `\\wsl.localhost`، وفي الحذف 0.9 ثانية مقابل 14 ثانية. والقاعدة هنا هي نفسها في الاتجاهين: الأداة تعمل أسرع ما يمكن عندما تكون في النظام نفسه الذي توجد فيه الملفات.

## Docker Desktop وWSL 2

قبل WSL 2 كان Docker Desktop على Windows يشغل آلة افتراضية خاصة به في Hyper-V اسمها MobyLinuxVM، وبعد WSL 2 أصبح الخيار الموصى به أن يستعمل الآلة الافتراضية نفسها التي يستعملها WSL. فعند تثبيته يضيف توزيعة `docker-desktop` التي رأيناها في المختبر، ويشغل فيها محرك Docker، بينما يبقى الأمر `docker` الذي تكتبه في PowerShell برنامج Windows يرسل طلباته إلى هذا المحرك. وإذا فعلت تكامل WSL في إعدادات Docker Desktop فسوف يظهر الأمر `docker` أيضاً داخل Ubuntu ويتكلم مع المحرك نفسه، فالصورة Image التي تبنيها من Ubuntu تراها من PowerShell والعكس، لأن المحرك واحد. وإذا كنت على Linux مباشرة فقد شرحنا [تثبيت Docker على Ubuntu](https://arabroot.io/articles/%D8%AA%D8%AB%D8%A8%D9%8A%D8%AA-docker-%D8%B9%D9%84%D9%89-ubuntu/) في دليل منفصل.

والسؤال المهم للمطور هو نفسه سؤال القسم السابق، لكن في صورة مختلفة: عندما تكتب `docker run -v C:\projects\api:/app` أو تضع في `compose.yaml` مسار مجلد من Windows، فإن الـ Container يعمل في Linux بينما الملفات في NTFS، وبالتالي تمر كل عملية ملف عبر 9P كما رأينا. والسكربت التالي يحاكي ما يفعله مشروع Node داخل Container: ينشئ 1,000 حزمة في `node_modules` بخمسة ملفات لكل حزمة كأنه `npm install`، ثم يقرأ ملف `package.json` والملف الرئيسي لكل حزمة كما يفعل `require()` عند تشغيل التطبيق، ثم يمر على الشجرة كلها بـ `lstat` كما يفعل `git status` أو أداة مراقبة الملفات، ثم يحذف المجلد:

```javascript
// What a Node project does to the disk, run inside a Linux container (Docker Desktop runs it in the WSL 2 VM):
//   node bench-node.mjs <dir> [packages]
// 1. "npm install": writes <packages> fake packages (package.json, index.js, two lib files, README) = 5 files each
// 2. "start the app": for each package, stat it, read and parse package.json, read its main file (what require() does)
// 3. "git status": walk the whole tree and lstat every entry
// 4. "rm -rf node_modules"
import { mkdirSync, writeFileSync, readFileSync, statSync, lstatSync, readdirSync, rmSync } from 'node:fs';
import { join } from 'node:path';

const root = process.argv[2]; const P = Number(process.argv[3] || 1000);
const ms = () => Number(process.hrtime.bigint() / 1000000n);
const body = 'module.exports = ' + JSON.stringify('x'.repeat(900)) + ';\n';
rmSync(root, { recursive: true, force: true });

let t = ms();
for (let i = 0; i < P; i++) {
  const d = join(root, 'node_modules', `pkg-${i}`);
  mkdirSync(join(d, 'lib'), { recursive: true });
  writeFileSync(join(d, 'package.json'), JSON.stringify({ name: `pkg-${i}`, version: '1.0.0', main: 'index.js' }));
  writeFileSync(join(d, 'index.js'), body);
  writeFileSync(join(d, 'lib', 'a.js'), body);
  writeFileSync(join(d, 'lib', 'b.js'), body);
  writeFileSync(join(d, 'README.md'), body);
}
const install = ms() - t;

t = ms(); let loaded = 0;
for (let i = 0; i < P; i++) {
  const d = join(root, 'node_modules', `pkg-${i}`);
  statSync(d);
  const pkg = JSON.parse(readFileSync(join(d, 'package.json'), 'utf8'));
  loaded += readFileSync(join(d, pkg.main)).length;
}
const start = ms() - t;

t = ms(); let entries = 0;
const walk = (d) => { for (const e of readdirSync(d)) { const p = join(d, e); entries++; if (lstatSync(p).isDirectory()) walk(p); } };
walk(root);
const status = ms() - t;

t = ms();
rmSync(root, { recursive: true, force: true });
const remove = ms() - t;

console.log(`install ${P * 5} files: ${install} ms | require ${P} packages: ${start} ms | lstat ${entries} entries: ${status} ms | delete: ${remove} ms`);
```

ونشغله ثلاث مرات في Container من `node:22-slim`، مرة على مجلد من Windows مربوط بالـ Container عبر Bind Mount، ومرة على Docker Volume يعيش داخل قرص WSL على ext4:

```powershell
  docker volume create arabroot-wsl-bench | Out-Null
  foreach ($t in @(@{ Name = 'bind mount from a Windows folder'; Arg = "${WinDir}:/work" }, @{ Name = 'Docker volume (ext4 inside WSL)'; Arg = 'arabroot-wsl-bench:/work' })) {
    "### $($t.Name)" | Out-Lab $o
    for ($r = 1; $r -le $Runs; $r++) {
      docker run --rm -v "$($t.Arg)" -v "${Lab}:/lab:ro" node:22-slim node /lab/bench-node.mjs /work/app 1000 | Out-Lab $o
    }
  }
  docker volume rm arabroot-wsl-bench | Out-Null
```

والمخرج سوف يكون كما يلي:

```text
### bind mount from a Windows folder
install 5000 files: 60649 ms | require 1000 packages: 10992 ms | lstat 7001 entries: 67941 ms | delete: 78304 ms
install 5000 files: 49673 ms | require 1000 packages: 12691 ms | lstat 7001 entries: 36919 ms | delete: 53267 ms
install 5000 files: 66322 ms | require 1000 packages: 6419 ms | lstat 7001 entries: 19034 ms | delete: 43505 ms
### Docker volume (ext4 inside WSL)
install 5000 files: 570 ms | require 1000 packages: 44 ms | lstat 7001 entries: 65 ms | delete: 312 ms
install 5000 files: 471 ms | require 1000 packages: 36 ms | lstat 7001 entries: 61 ms | delete: 307 ms
install 5000 files: 619 ms | require 1000 packages: 41 ms | lstat 7001 entries: 61 ms | delete: 228 ms
```

في المخرج أعلاه لاحظ التالي:

- "تثبيت" 5,000 ملف استغرق ما بين 49.7 و66.3 ثانية في المرات الثلاث على المجلد المربوط من Windows، مقابل ما بين 0.47 و0.62 ثانية على الـ Volume.
- تحميل 1,000 حزمة كما يفعل `require()` عند تشغيل التطبيق استغرق ما بين 6.4 و12.7 ثانية مقابل ما بين 36 و44 ms، وهذا هو الوقت الذي تنتظره كل مرة يعيد فيها `nodemon` أو خادم التطوير تشغيل التطبيق.
- المرور على 7,001 مدخل بـ `lstat` استغرق ما بين 19 و68 ثانية مقابل ما بين 61 و65 ms، وهذا ما تدفعه في كل مرة تفحص فيها أداة مراقبة الملفات File Watcher المشروع.

![رسم لـ Docker Desktop: على اليمين Windows وفيه docker.exe من PowerShell وVS Code ومجلد C:projectsapi على NTFS، وعلى اليسار WSL 2 VM وفيها توزيعة docker-desktop ومحرك dockerd الذي يستقبل الأوامر من docker.exe ويشغل container من node:22-slim فيه npm install وrequire() ومراقب الملفات على المسار /app. من الـ container سهم أخضر إلى Docker volume على ext4 مكتوب تحته 1,000 حزمة أقل من ثانية install 0.47-0.62 s، وسهم أحمر إلى bind mount عبر 9P ثم سهم متقطع إلى المجلد في Windows مكتوب تحته من قرص C يستغرق دقيقة تقريباً install 49.7-66.3 s](https://arabroot.io/content/images/2026/11/wsl2-for-developers-04-docker.webp)

المحرك يعمل داخل WSL، فالـ Volume يبقى داخل Linux، والمجلد المربوط من قرص C يعبر 9P في كل عملية ملف.

ولذلك تكتب Docker في [صفحة أفضل الممارسات مع WSL 2](https://docs.docker.com/desktop/features/wsl/best-practices/?ref=arabroot.io) أن أفضل أداء للملفات المربوطة يكون عندما تضع الكود والبيانات التي تربطها بالـ Container في نظام ملفات Linux وليس في Windows. والتطبيق العملي لهذه القاعدة بسيط: انسخ المشروع إلى `~/projects` داخل Ubuntu، وشغل `docker compose up` من هناك، وعندها يكون المسار المربوط مساراً داخل Linux فلا يعبر أي ملف إلى Windows، أما قواعد البيانات وملفات `node_modules` فضعها في Volumes وليس في مجلدات مربوطة.

📌

Docker Desktop ليس مجانياً لكل الشركات. بحسب [صفحة الترخيص](https://docs.docker.com/subscription-billing/desktop-license/?ref=arabroot.io) فهو مجاني للشركات الصغيرة التي فيها أقل من 250 موظفاً وإيراد سنوي أقل من 10 ملايين دولار معاً، وللاستعمال الشخصي والتعليم والمشاريع مفتوحة المصدر غير التجارية، ويحتاج اشتراكاً مدفوعاً للاستعمال المهني في الشركات الأكبر والجهات الحكومية. وإذا كانت شركتك أكبر من ذلك فالبديل الذي لا يحتاج ترخيصاً هو أن تثبت محرك Docker نفسه داخل توزيعة Ubuntu في WSL كما تثبته على أي سيرفر Linux.

## الشبكة: لماذا يصل Windows إلى Linux ولا يصل Linux إلى Windows؟

الآلة الافتراضية لها كرت شبكة افتراضي وعنوان IP خاص بها، وبحسب [صفحة الشبكة في WSL](https://learn.microsoft.com/en-us/windows/wsl/networking?ref=arabroot.io) فالوضع الافتراضي هو NAT، وقد شرحنا فكرته في [مقال ما هو NAT](https://arabroot.io/articles/%D9%85%D8%A7-%D9%87%D9%88-nat-%D8%B4%D8%B1%D8%AD-%D9%84%D9%84%D9%85%D8%A8%D8%AA%D8%AF%D8%A6%D9%8A%D9%86/): Windows يقف أمام الآلة الافتراضية كما يقف الراوتر Router في بيتك أمام أجهزتك، فتخرج الآلة الافتراضية إلى الإنترنت عبر عنوان Windows، بينما عنوانها الخاص لا يراه أحد خارج الجهاز. ثم أضاف WSL فوق هذا ميزة اسمها تمرير localhost (Localhost Forwarding): أي برنامج في Linux يستمع على `localhost` أو على كل العناوين `0.0.0.0` يصل إليه Windows عبر `localhost` نفسه، ولذلك يعمل خادم التطوير في Ubuntu وتفتحه من Chrome في Windows دون أن تعرف عنوان الآلة الافتراضية.

والقسم الخامس من المختبر يختبر هذا في الاتجاهين، ويحتاج سيرفراً صغيراً داخل Linux، وBusyBox فيه الأمر `nc` الذي يكفي لسيرفر يرد على طلب واحد ثم يتوقف:

```bash
#!/bin/sh
# A one-request HTTP server inside WSL (BusyBox nc is enough):  sh server.sh <listen-address> <port> [seconds]
# It answers the first request with a short text and exits; it stops by itself after [seconds] (default 20).
ADDR=$1; PORT=$2; SECS=${3:-20}
BODY="hello from Linux, kernel $(uname -r), listening on $ADDR:$PORT"
printf 'HTTP/1.0 200 OK\r\nContent-Type: text/plain\r\nContent-Length: %s\r\n\r\n%s' "${#BODY}" "$BODY" \
  | timeout "$SECS" nc -l -s "$ADDR" -p "$PORT" > /dev/null
```

وفي جهة Windows نشغل سيرفراً صغيراً بـ `HttpListener` من .NET على `localhost:8770`، وهو لا يحتاج صلاحيات المسؤول لأنه يستمع على localhost فقط، ثم نطلب كل سيرفر من الجهة الأخرى، والمخرج سوف يكون كما يلي:

```text
networking mode: nat, Linux eth0: 172.26.145.18, Windows as seen from Linux (default gateway): 172.26.144.1
### 1. A server in Linux on 127.0.0.1:8765, opened from Windows
  http://localhost:8765/ -> 200: hello from Linux, kernel 5.15.167.4-microsoft-standard-WSL2, listening on 127.0.0.1:8765
### 2. A server in Linux on 0.0.0.0:8766, opened from Windows by the Linux IP address
  http://172.26.145.18:8766/ -> 200: hello from Linux, kernel 5.15.167.4-microsoft-standard-WSL2, listening on 0.0.0.0:8766
### 3. A server in Windows on localhost:8770, opened from Linux
  (from Windows itself)  http://localhost:8770/ -> 200: hello from Windows
  from Linux: http://127.0.0.1:8770/ -> failed: wget: can't connect to remote host (127.0.0.1): Connection refused
  from Linux: http://172.26.144.1:8770/ -> failed: wget: download timed out
```

في المخرج أعلاه لاحظ التالي:

- عنوان Linux هو `172.26.145.18`، وWindows يظهر له على العنوان `172.26.144.1` وهو البوابة الافتراضية Default Gateway، وهذه شبكة خاصة لا وجود لها خارج الجهاز.
- السيرفر الذي في Linux على `127.0.0.1:8765` وصل إليه Windows عبر `localhost:8765`، وهذا هو تمرير localhost. والسيرفر على `0.0.0.0:8766` وصل إليه Windows أيضاً عبر عنوان Linux مباشرة.
- السيرفر الذي في Windows على `localhost:8770` رد على Windows نفسه، لكن Linux عندما طلب `127.0.0.1:8770` رفض الاتصال، والسبب أن `127.0.0.1` داخل Linux هو Linux نفسه وليس Windows، والتمرير يعمل في اتجاه واحد فقط. وعندما طلب Linux عنوان Windows على الشبكة الخاصة `172.26.144.1` انتهت المهلة، لأن السيرفر يستمع على localhost فقط، والجدار الناري Firewall في Windows لا يسمح بالاتصالات الواردة من هذه الشبكة إلا إذا أضفت له قاعدة.

![رسم للشبكة في الوضع NAT: على اليمين جهاز Windows وفيه localhost يساوي 127.0.0.1 وسيرفر على localhost:8770 والمتصفح وcurl وPostman، وفي الوسط NAT على العنوان 172.26.144.1، وعلى اليسار WSL 2 VM بعنوان eth0 172.26.145.18 وفيه سيرفر على 127.0.0.1:8765 وآخر على 0.0.0.0:8766. سهم أخضر من المتصفح في Windows إلى السيرفر في Linux مكتوب عليه من Windows إلى localhost:8765 يعمل، وسهم أحمر متقطع من Linux إلى Windows مكتوب عليه من Linux إلى 127.0.0.1:8770 يرفض الاتصال لأن 127.0.0.1 داخل Linux هو Linux نفسه. وفي الأسفل الوضع Mirrored بالإعداد networkingMode=mirrored في ملف .wslconfig وعبارة localhost يعمل في الاتجاهين](https://arabroot.io/content/images/2026/11/wsl2-for-developers-03-network.webp)

في الوضع NAT يمرر WSL منافذ Linux إلى localhost في Windows، ولا يمرر منافذ Windows إلى Linux، والوضع Mirrored يجعل الشبكة واحدة في الجهتين.

وهذا الاتجاه الثاني هو الذي يقع فيه المطورون كثيراً: قاعدة البيانات SQL Server أو PostgreSQL مثبتة في Windows، والتطبيق يعمل في WSL، والإعداد يقول `localhost:5432`، فيرفض الاتصال. والحل في الوضع NAT أن تستعمل عنوان Windows الذي تراه من Linux، وتسمح للسيرفر بالاستماع على هذا العنوان، وتضيف قاعدة في الجدار الناري. لكن الحل الأنظف على Windows 11 بالإصدار 22H2 وما بعده هو الوضع Mirrored، الذي تفعله بسطر واحد في الملف `%UserProfile%\.wslconfig`:

```ini
[wsl2]
networkingMode=mirrored
```

وفي هذا الوضع بحسب التوثيق تنعكس كروت الشبكة في Windows داخل Linux، ويستطيع كل طرف أن يصل إلى الآخر عبر `127.0.0.1`، فلا تحتاج أن تعرف أي عنوان خاص. ولم نفعله في المختبر لأن المختبر لا يغير إعدادات الجهاز، فإذا فعلته عندك فأعد تشغيل القسم الخامس وسوف ترى أن الطلب من Linux إلى `127.0.0.1:8770` نجح.

## الذاكرة والمعالج: ملف .wslconfig

رأينا أن Linux يرى 32,036 MB من الذاكرة و8 معالجات، وهذا ليس ما يحجزه فعلاً وإنما السقف الذي يسمح له به، فالآلة الافتراضية في WSL 2 تبدأ صغيرة وتطلب من Windows ذاكرة كلما احتاجت. والقيم الافتراضية بحسب [صفحة الإعدادات](https://learn.microsoft.com/en-us/windows/wsl/wsl-config?ref=arabroot.io) هي 50% من ذاكرة Windows، وكل المعالجات المنطقية، والقسم السابع من المختبر يقرأ الذاكرة من الجهتين:

```text
### memory inside Linux (free -m)
              total        used        free      shared  buff/cache   available
Mem:          32036        2556       25780          42        3700       28989
Swap:          8192           4        8188
### the WSL VM as seen by Windows
vmmemWSL: working set 5,076 MB
running distributions: docker-desktop
```

في المخرج أعلاه لاحظ أن Linux يستعمل 2,556 MB لبرامجه و3,700 MB ذاكرة مؤقتة Cache للملفات، بينما يرى مدير المهام في Windows عملية اسمها `vmmemWSL` تأخذ 5,076 MB، وهذه العملية هي الآلة الافتراضية كلها كما يراها Windows: برامج Linux والـ Cache معاً. والـ Swap هنا 8,192 MB، أي ربع ذاكرة الآلة الافتراضية.

![رسم بأشرطة أفقية: ذاكرة الجهاز Windows 63.9 GB و8 معالجات منطقية، ثم سقف الذاكرة WSL 2 VM 32,036 MB و8 معالجات بنصف طول الشريط الأول مع عبارة الافتراضي نصف الذاكرة وكل المعالجات، ثم المستخدم الآن شريط قصير vmmemWSL 5,076 MB في مدير المهام، وفي الأسفل مربع فيه ملف %UserProfile%\.wslconfig والسطر [wsl2] memory=8GB processors=4 swap=4GB وعبارة تغير السقف من هنا ثم wsl --shutdown](https://arabroot.io/content/images/2026/11/wsl2-for-developers-05-memory.webp)

الآلة الافتراضية تأخذ من الذاكرة ما تحتاجه حتى سقف نصف ذاكرة الجهاز، و`vmmemWSL` في مدير المهام هو ما تأخذه الآن فعلاً.

والمشكلة التي اشتكى منها المطورون مع WSL 2 كانت في هذه الـ Cache تحديداً. ففي 17 يونيو 2019 فتح أحد المطورين [الطلب 4166 في مستودع WSL](https://github.com/microsoft/WSL/issues/4166?ref=arabroot.io) بعنوان WSL 2 يستهلك كميات ضخمة من الذاكرة ولا يرجعها، لأن Linux يستعمل كل ذاكرة فارغة عنده كـ Cache للملفات، وهذا تصرف صحيح في سيرفر Linux، لكنه في آلة افتراضية يعني أن الذاكرة تبقى محجوزة من Windows حتى لو انتهى البناء الذي استعملها. وما زالت [صفحة المقارنة](https://learn.microsoft.com/en-us/windows/wsl/compare-versions?ref=arabroot.io) تشير إلى هذا الطلب وتقول إن الذاكرة التي يحررها البرنامج ترجع إلى Windows تلقائياً، أما الـ Cache فقد لا ترجع حتى تتوقف الآلة الافتراضية، وأضيف بعد ذلك الإعداد `autoMemoryReclaim` في القسم `[experimental]` من `.wslconfig` بقيمه `gradual` لاسترجاع الذاكرة المؤقتة تدريجياً و`dropCache` لاسترجاعها فوراً و`disabled` لإيقافه.

وإذا كان جهازك فيه 16 GB فإن نصفها لـ WSL قد يكون كثيراً عندما تعمل معه قواعد بيانات في Docker ومتصفح ومحرر، والحل أن تحدد السقف بنفسك في الملف `%UserProfile%\.wslconfig`، وهو ملف غير موجود افتراضياً تنشئه بنفسك:

```ini
[wsl2]
memory=8GB          # السقف، والافتراضي نصف ذاكرة Windows
processors=4        # الافتراضي كل المعالجات المنطقية
swap=4GB            # 0 لإلغاء الـ Swap

[experimental]
autoMemoryReclaim=gradual
```

ثم أغلق كل التوزيعات بالأمر `wsl --shutdown` حتى تطبق الإعدادات، والسبب أن الآلة الافتراضية لا تقرأ الملف إلا عند تشغيلها، وتذكر أن هذا الأمر يوقف كل التوزيعات ومعها Docker Desktop، فلا تقم به أثناء بناء أو اختبار يعمل. ويجدر الإشارة هنا إلى الفرق بين ملفين بأسماء متشابهة: `.wslconfig` في مجلد المستخدم في Windows يضبط الآلة الافتراضية كلها لكل التوزيعات، مثل الذاكرة والمعالج والشبكة، بينما `/etc/wsl.conf` داخل كل توزيعة يضبط تلك التوزيعة وحدها، مثل مكان أقراص Windows والمستخدم الافتراضي وsystemd، وهو الملف الذي رأينا فيه `root = /mnt/host` في توزيعة Docker.

## systemd داخل WSL

في المختبر رأينا أن العملية رقم 1 هي `/init`، وهذا يعني أن التوزيعة لا تشغل systemd، وبالتالي فالأوامر التي تعودت عليها في السيرفر مثل `systemctl enable --now postgresql` لا تعمل، وقد شرحنا systemd وخدماته في [مقال الخدمات والسجلات مع systemd](https://arabroot.io/articles/%D8%A7%D9%84%D8%AE%D8%AF%D9%85%D8%A7%D8%AA-services-%D9%88%D8%A7%D9%84%D8%B3%D8%AC%D9%84%D8%A7%D8%AA-logs-%D9%85%D8%B9-systemd-%D9%88-journalctl/). وبحسب [صفحة systemd في WSL](https://learn.microsoft.com/en-us/windows/wsl/systemd?ref=arabroot.io) أصبح systemd مدعوماً من إصدار WSL 0.67.6، وأصبح الافتراضي في إصدار Ubuntu الحالي الذي يثبته `wsl --install`، أما التوزيعات الأخرى فقد تبقى على `init` الخاص بـ WSL، وتفعله فيها بسطرين في `/etc/wsl.conf` داخل التوزيعة:

```ini
[boot]
systemd=true
```

ثم `wsl --shutdown` من PowerShell، وعند فتح التوزيعة مرة أخرى يكون systemd هو العملية رقم 1، وتتحقق بالأمر `systemctl list-unit-files --type=service`. وهل تحتاجه دائماً؟ لا، فإذا كنت تستعمل WSL للطرفية والأدوات والبناء فقط فلا حاجة له، وكل خدمة يشغلها systemd تأخذ من الذاكرة ومن وقت الإقلاع، لكنه مهم إذا كنت تريد أن تجرب خدمة كما تعمل على السيرفر بالضبط، أو تستعمل أدوات تفترض وجوده مثل `snap`.

## التشغيل المتبادل: برامج Windows من Linux والعكس

من مزايا WSL أن الحدود بين النظامين في سطر الأوامر شبه غير موجودة: من PowerShell تستطيع أن تشغل أمر Linux وتمرر مخرجه إلى أمر PowerShell، ومن Linux تستطيع أن تشغل `explorer.exe .` أو `code .` أو أي ملف `.exe`. والقسم السادس من المختبر يجرب هذا، ويجرب معه مشكلة حالة الأحرف في أسماء الملفات بالسكربت التالي:

```bash
#!/bin/sh
# Two files whose names differ only in case, in a Linux (ext4) folder and in a Windows (NTFS) folder:
#   sh case.sh <dir>
D=$1; rm -rf "$D"; mkdir -p "$D"
printf 'first\n' > "$D/README.md"
printf 'second\n' > "$D/readme.md"
echo "files in $D:"; ls "$D"
echo "README.md contains: $(cat "$D/README.md")"
```

والمخرج سوف يكون كما يلي:

```text
### Linux path -> Windows path (wslpath -w)
\\wsl.localhost\docker-desktop\etc
### a Windows program started from Linux
<3>WSL (2951238 - Relay) ERROR: CreateProcessCommon:640: execvpe(/mnt/host/c/Windows/System32/cmd.exe) failed: Exec format error
### who runs .exe files inside Linux: the binfmt_misc entries
python3.13
register
status
### a Linux program in a PowerShell pipeline
model name	: Intel(R) Core(TM) i7-7700K CPU @ 4.20GHz
### the same two file names, on ext4 and on NTFS
files in /mnt/docker-desktop-disk/arabroot-wsl-bench-case:
README.md
readme.md
README.md contains: first
files in /mnt/host/c/work/wsl-lab/data/case:
README.md
README.md contains: second
and from PowerShell: README.md
```

في المخرج أعلاه لاحظ التالي:

- الأمر `wslpath -w /etc` حول مسار Linux إلى المسار الذي يفتحه Windows `\\wsl.localhost\docker-desktop\etc`، والأمر نفسه بالخيار `-u` يحول مسار Windows إلى مسار Linux، وهو مفيد في السكربتات التي تمرر مسارات بين النظامين.
- أمر Linux `cat /proc/cpuinfo` عمل داخل pipeline في PowerShell، ومرر مخرجه إلى `Select-String` كأي برنامج آخر.
- تشغيل `cmd.exe` من داخل هذه التوزيعة فشل بالرسالة `Exec format error`، وهي الرسالة نفسها التي تراها في Linux عندما تحاول أن تشغل ملفاً لا تعرف النواة صيغته. والسبب أن نواة Linux لا تعرف كيف تشغل ملف `.exe` بصيغة PE، وإنما يعلمها WSL ذلك بتسجيل صيغة هذه الملفات في `binfmt_misc` باسم `WSLInterop`، فتحول النواة كل ملف `.exe` إلى برنامج WSL الذي يشغله في Windows، كما في [صفحة أنظمة الملفات](https://learn.microsoft.com/en-us/windows/wsl/filesystems?ref=arabroot.io). والقائمة التي تلي الخطأ فيها الملفان `register` و`status` اللذان يأتيان مع `binfmt_misc` وتسجيل واحد لصيغة أخرى، ولا يوجد فيها `WSLInterop`، أي أن هذا التسجيل غير موجود في توزيعة `docker-desktop` رغم أن `wsl.conf` فيها يقول `enabled = true`، ولذلك فالخطوة الأولى عندما ترى هذا الخطأ في توزيعتك أن تتحقق من وجود الملف `/proc/sys/fs/binfmt_misc/WSLInterop`.
- في مجلد ext4 أنشأ السكربت ملفين `README.md` و`readme.md`، وبقي كل منهما بمحتواه، لأن Linux يفرق بين الأحرف الكبيرة والصغيرة. أما في مجلد على قرص C فبقي ملف واحد، والكتابة في `readme.md` كتبت فوق `README.md` فأصبح محتواه `second`، لأن مجلدات Windows لا تفرق بين حالة الأحرف بشكل افتراضي.

💡

في سبتمبر 2022، بعد أيام من إضافة دعم systemd إلى WSL، فتح المستخدمون [الطلب 8843](https://github.com/microsoft/WSL/issues/8843?ref=arabroot.io) بعنوان لا يمكن تشغيل برامج Windows عند تفعيل systemd، وكان الخطأ هو `Exec format error` نفسه الذي رأيناه في المختبر، لأن خدمة من خدمات systemd كانت تعيد ضبط تسجيلات `binfmt_misc` عند الإقلاع فتمحو تسجيل WSL. وأضيف بعد ذلك الإعداد `protectBinfmt` في القسم `[boot]` من `wsl.conf`، وقيمته الافتراضية `true`، ليمنع هذا التعارض بحسب [صفحة الإعدادات](https://learn.microsoft.com/en-us/windows/wsl/wsl-config?ref=arabroot.io). والدرس أن كل ما يربط النظامين في WSL مبني على آليات Linux عادية، وإذا تعطل فابحث عنه بأدوات Linux نفسها.

ومشكلة حالة الأحرف ليست نظرية: مستودع Git فيه ملفان `Logo.png` و`logo.png` أنشأهما زميل على Mac أو Linux، فإذا استنسخته في `/mnt/c` فسوف يكتب أحدهما فوق الآخر، ويظهر `git status` تعديلاً لم تقم به. وبحسب [صفحة حالة الأحرف في WSL](https://learn.microsoft.com/en-us/windows/wsl/case-sensitivity?ref=arabroot.io) تستطيع أن تجعل مجلداً في Windows يفرق بين الأحرف بالأمر `fsutil.exe file setCaseSensitiveInfo <path> enable` من PowerShell بصلاحيات المسؤول على مجلد فارغ، لكن الحل الأبسط هو القاعدة نفسها التي خرجنا بها من قياس الأداء: ضع المشروع داخل Linux، فهناك تحصل على الأداء وعلى سلوك الملفات نفسه الذي في السيرفر.

## أوامر WSL التي تحتاجها كل يوم

كل إدارة WSL تتم من الأمر `wsl` في PowerShell، والجدول التالي يجمع الأوامر التي يحتاجها المطور من [صفحة الأوامر الأساسية](https://learn.microsoft.com/en-us/windows/wsl/basic-commands?ref=arabroot.io):

| الأمر                          | ماذا يفعل                                                                 |
| ------------------------------ | ------------------------------------------------------------------------- |
| wsl -l -v                      | التوزيعات المثبتة وحالتها وهل هي WSL 1 أو 2                               |
| wsl -d Ubuntu                  | يفتح توزيعة بالاسم، وwsl -d Ubuntu -e uname -r يشغل فيها أمراً واحداً     |
| wsl --shutdown                 | يوقف كل التوزيعات والآلة الافتراضية فوراً، وتحتاجه بعد تعديل .wslconfig   |
| wsl --terminate Ubuntu         | يوقف توزيعة واحدة فقط                                                     |
| wsl --export Ubuntu ubuntu.tar | نسخة احتياطية Backup من التوزيعة كاملة في ملف tar، أو VHDX بالخيار \--vhd |
| wsl --import                   | يستعيد التوزيعة من ملف التصدير، على الجهاز نفسه أو جهاز جديد              |
| wsl --update                   | يحدث WSL والنواة معه                                                      |
| wsl --set-version Ubuntu 1     | يحول التوزيعة بين WSL 1 وWSL 2                                            |

ويجدر الإشارة إلى أن القرص الافتراضي لكل توزيعة ملف اسمه `ext4.vhdx` على قرص Windows، ويبدأ بسقف 1 TB بحسب [صفحة مساحة القرص](https://learn.microsoft.com/en-us/windows/wsl/disk-space?ref=arabroot.io) ويكبر كلما أضفت ملفات، وهذا ما رأيناه في توزيعة Docker التي ظهر قرص بياناتها بحجم 1006.9G. لكن هذا الملف لا يصغر وحده عندما تحذف الملفات من داخل Linux، ولذلك إذا بنيت Images كثيرة ثم حذفتها فقد تجد أن المساحة على قرص C لم ترجع، وهذا سبب إضافي لأن تأخذ نسخة احتياطية بـ `wsl --export` قبل أي تنظيف.

## أخطاء شائعة

- **المشروع في `/mnt/c` والعمل من Linux:** كل `npm install` و`git status` وبناء يصبح أبطأ بعشرات المرات كما رأينا في المختبر. انقل المشروع إلى `~/` داخل التوزيعة.
- **ربط مجلد من Windows في Docker:** المسار `C:\...` في `compose.yaml` يمر عبر 9P في كل عملية ملف، وخادم التطوير ومراقب الملفات يدفعان الثمن. شغل `docker compose` من داخل Linux على مشروع في Linux.
- **`localhost` من Linux إلى Windows:** في الوضع NAT لا يصل Linux إلى سيرفر في Windows عبر `127.0.0.1`. فعل الوضع Mirrored على Windows 11، أو استعمل عنوان البوابة مع قاعدة في الجدار الناري.
- **تعديل `.wslconfig` دون إعادة التشغيل:** الإعدادات لا تطبق حتى تتوقف الآلة الافتراضية كلها، فاستعمل `wsl --shutdown` ثم تحقق بـ `wsl -l --running`.
- **الخلط بين `.wslconfig` و`wsl.conf`:** الذاكرة والمعالج والشبكة في الأول داخل مجلد المستخدم في Windows، وsystemd ومكان الأقراص والمستخدم في الثاني داخل `/etc` في كل توزيعة.
- **الحكم على الذاكرة من `vmmemWSL` وحده:** الرقم في مدير المهام يشمل الـ Cache داخل Linux، فاقرأ `free -m` من الداخل قبل أن تحكم أن برنامجاً يسرب الذاكرة.
- **فتح ملفات Linux من محرر Windows عبر `\\wsl.localhost`:** القراءة أبطأ بنحو مئة مرة كما قسنا، فافتح المحرر من داخل التوزيعة بـ `code .`.

## تطبيق عملي

1. شغل `run.ps1` على جهازك بالخيار `-Distro` لتوزيعتك، وقارن أرقام القسم الثاني بأرقامنا، ثم أوقف مضاد الفيروسات عن مجلد الاختبار إذا كانت سياسة شركتك تسمح وأعد القياس على قرص C، ولاحظ كم من الفرق سببه 9P وكم سببه الفحص.
2. خذ مشروعاً حقيقياً من مشاريعك، واستنسخه مرة في `/mnt/c` ومرة في `~/`، ثم شغل `time npm install` أو `time git status` في المكانين.
3. على Windows 11 أنشئ `.wslconfig` بالسطر `networkingMode=mirrored`، ثم `wsl --shutdown`، وأعد القسم الخامس من المختبر، وتحقق أن Linux أصبح يصل إلى السيرفر في Windows عبر `127.0.0.1`، ثم احذف السطر إذا لم تكن تحتاجه.

## الخلاصة

- WSL 1 كان يترجم استدعاءات Linux داخل نواة Windows عبر `lxcore.sys`، وWSL 2 يشغل نواة Linux حقيقية في آلة افتراضية خفيفة تديرها Windows، ولذلك يعمل فيه Docker وsystemd وكل برامج Linux.
- كل التوزيعات ومعها Docker Desktop تعمل في آلة افتراضية واحدة ونواة واحدة، وتشترك في الذاكرة والشبكة.
- ملفات ext4 داخل Linux سريعة، وملفات `/mnt/c` تعبر إلى Windows عبر 9P، وفي المختبر كان إنشاء 5,000 ملف صغير 60.1 ثانية على C مقابل 0.52 ثانية على ext4، فضع مشروعك حيث تعمل أدواتك.
- المجلد المربوط من Windows في Docker يدفع الثمن نفسه، فشغل `docker compose` من مشروع داخل Linux، وضع البيانات في Volumes.
- في الوضع NAT يصل Windows إلى منافذ Linux عبر `localhost` ولا يصل Linux إلى Windows بالطريقة نفسها، والوضع Mirrored على Windows 11 يحل ذلك.
- السقف الافتراضي للذاكرة نصف ذاكرة الجهاز، وتغيره في `.wslconfig` ثم `wsl --shutdown`، وsystemd تفعله في `wsl.conf` لكل توزيعة.

وفي المقالات القادمة من هذه المرحلة بإذن الله سوف نتحدث عن الخدمات Services في Windows وكيف تديرها، وعن سجل Windows Registry، وإذا لم تقرأ بعد مقالات المرحلة السابقة فهذه هي:

[![](https://arabroot.io/content/images/2026/11/windows-architecture-cover-cover.webp)دليلكيف يعمل Windows من الداخل؟ وضع المستخدم والنواة والخدماتما الذي يعمل تحت سطح مكتب Windows: طبقاته من البرنامج إلى العتاد، ولماذا يغلق البرنامج وحده بينما يوقف التعريف الجهاز كله، ومن يشغل من عند الإقلاع، مع مختبر PowerShell على Windows 11.](https://arabroot.io/articles/%D9%83%D9%8A%D9%81-%D9%8A%D8%B9%D9%85%D9%84-windows-%D9%85%D9%86-%D8%A7%D9%84%D8%AF%D8%A7%D8%AE%D9%84-%D9%88%D8%B6%D8%B9-%D8%A7%D9%84%D9%85%D8%B3%D8%AA%D8%AE%D8%AF%D9%85-%D9%88%D8%A7%D9%84%D9%86%D9%88%D8%A7%D8%A9/)[![](https://arabroot.io/content/images/2026/11/powershell-basics-cover-cover.webp)دليلPowerShell للمسؤولين: الكائنات Objects بدل النصلماذا ينكسر السكربت الذي يقص مخرج الأوامر في Windows، وكيف تبني بكائنات PowerShell تقريراً صباحياً عن الأقراص والخدمات والأخطاء يعمل في 5.1 و7 دون صلاحيات المدير.](https://arabroot.io/articles/powershell-%D9%84%D9%84%D9%85%D8%B3%D8%A4%D9%88%D9%84%D9%8A%D9%86-%D8%A7%D9%84%D9%83%D8%A7%D8%A6%D9%86%D8%A7%D8%AA-%D8%A8%D8%AF%D9%84-%D8%A7%D9%84%D9%86%D8%B5/)[![](https://arabroot.io/content/images/2026/11/windows-event-viewer-cover-cover.webp)دليلسجلات الأحداث Event Viewer: كيف تقرأ ما حدث في جهازككيف تعرف من سجلات Windows لماذا أعاد جهازك التشغيل وحده، من التحديث إلى الشاشة الزرقاء إلى زر الطاقة، بعارض الأحداث وPowerShell دون صلاحيات المسؤول.](https://arabroot.io/articles/%D8%B3%D8%AC%D9%84%D8%A7%D8%AA-%D8%A7%D9%84%D8%A7%D8%AD%D8%AF%D8%A7%D8%AB-event-viewer-%D9%83%D9%8A%D9%81-%D8%AA%D9%82%D8%B1%D8%A7-%D9%85%D8%A7-%D8%AD%D8%AF%D8%AB-%D9%81%D9%8A-%D8%AC%D9%87%D8%A7%D8%B2%D9%83/)[![](https://arabroot.io/content/images/2026/11/linux-intro-cover-cover.webp)دليلما هو Linux؟ التوزيعات Distributions وأيها تختارالفرق بين نواة Linux والتوزيعة، والعائلات التي تجمع مئات التوزيعات، وأي توزيعة تختار للسيرفر أو للتعلم، وكيف تجربها دون أن تمسح جهازك.](https://arabroot.io/articles/%D9%85%D8%A7-%D9%87%D9%88-linux-%D9%88%D8%A7%D9%84%D8%AA%D9%88%D8%B2%D9%8A%D8%B9%D8%A7%D8%AA-%D9%88%D8%A7%D9%8A%D9%87%D8%A7-%D8%AA%D8%AE%D8%AA%D8%A7%D8%B1/)[![](https://arabroot.io/content/images/2026/11/terminal-emulators-cover-cover.webp)دليلبرامج الطرفية Terminal Emulators: أيها تختار؟جربنا Windows Terminal وWezTerm وAlacritty وGhostty على Windows وLinux، وقسنا زمن البدء والذاكرة، واختبرنا عرض النص العربي في كل منها حتى تختار برنامج الطرفية الذي يناسب عملك.](https://arabroot.io/articles/%D8%A8%D8%B1%D8%A7%D9%85%D8%AC-%D8%A7%D9%84%D8%B7%D8%B1%D9%81%D9%8A%D8%A9-terminal-emulators-%D8%A7%D9%8A%D9%87%D8%A7-%D8%AA%D8%AE%D8%AA%D8%A7%D8%B1/)

## سجل التحديثات Changelog

- نوفمبر 2026: كتابة المقال، وتشغيل المختبر على Windows 11 Pro 24H2 (البناء 26100.9711) مع WSL 2.4.11 والنواة 5.15.167.4 وتوزيعة docker-desktop من Docker Desktop مع Docker Engine 29.8.0، بصلاحيات مستخدم عادي.