diff --git a/Project.toml b/Project.toml
index a5e42cf..e8a33e7 100644
--- a/Project.toml
+++ b/Project.toml
@@ -10,16 +10,18 @@ SDL2_gfx_jll = "323748d4-b4be-59be-a22c-1904c60787cb"
 SDL2_image_jll = "41f3cfe1-fd11-58ad-8074-b9730c29438b"
 SDL2_jll = "ab825dc5-c88e-5901-9575-1e5e20358fcf"
 SDL2_mixer_jll = "7e88e5ca-120e-58e7-9660-b2187fd466c0"
+SDL2_net_jll = "f85291cd-a23d-5685-85d1-de13e1abbd3f"
 SDL2_ttf_jll = "ca9d4746-8a27-5104-babe-80f83b336947"
 alsa_plugins_jll = "5ac2f6bb-493e-5871-9171-112d4c21a6e7"
 
 [compat]
 CEnum = "0.4"
 ColorTypes = "0.8, 0.9, 0.10, 0.11"
-SDL2_gfx_jll = "1.0.3"
+SDL2_gfx_jll = "1.0.4"
 SDL2_image_jll = "2.6.2"
 SDL2_jll = "2.24.2"
 SDL2_mixer_jll = "2.6.2"
+SDL2_net_jll = "2.2.0"
 SDL2_ttf_jll = "2.0.15"
 julia = "1.3"
 
diff --git a/gen/generator.jl b/gen/generator.jl
index 0134490..fa70ecd 100644
--- a/gen/generator.jl
+++ b/gen/generator.jl
@@ -5,6 +5,7 @@ using SDL2_mixer_jll
 using SDL2_image_jll
 using SDL2_ttf_jll
 using SDL2_gfx_jll
+using SDL2_net_jll
 
 cd(@__DIR__)
 
@@ -18,6 +19,7 @@ sdl_framerate_h = joinpath(sdl_gfx_include_dir, "SDL2", "SDL2_framerate.h")
 sdl_gfxPrimitives_h = joinpath(sdl_gfx_include_dir, "SDL2", "SDL2_gfxPrimitives.h")
 sdl_imageFilter_h = joinpath(sdl_gfx_include_dir, "SDL2", "SDL2_imageFilter.h")
 sdl_rotozoom_h = joinpath(sdl_gfx_include_dir, "SDL2", "SDL2_rotozoom.h")
+sdl_net_h = joinpath(SDL2_net_jll.artifact_dir, "include", "SDL2", "SDL_net.h")
 
 local_include_dir = joinpath(@__DIR__, "include")
 isdir(local_include_dir) && rm(local_include_dir, recursive=true)
@@ -29,6 +31,7 @@ cp(sdl_framerate_h, joinpath(@__DIR__, "include", "SDL2", basename(sdl_framerate
 cp(sdl_gfxPrimitives_h, joinpath(@__DIR__, "include", "SDL2", basename(sdl_gfxPrimitives_h)))
 cp(sdl_imageFilter_h, joinpath(@__DIR__, "include", "SDL2", basename(sdl_imageFilter_h)))
 cp(sdl_rotozoom_h, joinpath(@__DIR__, "include", "SDL2", basename(sdl_rotozoom_h)))
+cp(sdl_net_h, joinpath(@__DIR__, "include", "SDL2", basename(sdl_net_h)))
 
 sdl_mixer_h = joinpath(local_include_dir, "SDL2", "SDL_mixer.h")
 sdl_image_h = joinpath(local_include_dir, "SDL2", "SDL_image.h")
@@ -38,6 +41,7 @@ sdl_framerate_h = joinpath(local_include_dir, "SDL2", "SDL2_framerate.h")
 sdl_gfxPrimitives_h = joinpath(local_include_dir, "SDL2", "SDL2_gfxPrimitives.h")
 sdl_imageFilter_h = joinpath(local_include_dir, "SDL2", "SDL2_imageFilter.h")
 sdl_rotozoom_h = joinpath(local_include_dir, "SDL2", "SDL2_rotozoom.h")
+sdl_net_h = joinpath(local_include_dir, "SDL2", "SDL_net.h")
 
 
 options = load_options(joinpath(@__DIR__, "generator.toml"))
@@ -45,6 +49,6 @@ options = load_options(joinpath(@__DIR__, "generator.toml"))
 args = get_default_args()
 push!(args, "-I$local_include_dir")
 
-ctx = create_context([sdl_h, sdl_mixer_h, sdl_image_h, sdl_ttf_h, sdl_framerate_h, sdl_gfxPrimitives_h, sdl_imageFilter_h, sdl_rotozoom_h], args, options)
+ctx = create_context([sdl_h, sdl_mixer_h, sdl_image_h, sdl_ttf_h, sdl_framerate_h, sdl_gfxPrimitives_h, sdl_imageFilter_h, sdl_rotozoom_h, sdl_net_h], args, options)
 
 build!(ctx)
diff --git a/gen/generator.toml b/gen/generator.toml
index 19e1f47..da995c6 100644
--- a/gen/generator.toml
+++ b/gen/generator.toml
@@ -1,10 +1,10 @@
 [general]
 library_name = "libsdl2"
-library_names = {"SDL2/SDL_mixer.h" = "libsdl2_mixer", "SDL2/SDL_image.h" = "libsdl2_image", "SDL2/SDL_ttf.h" = "libsdl2_ttf", "SDL2/SDL2_framerate.h" = "libsdl2_gfx", "SDL2/SDL2_gfxPrimitives.h" = "libsdl2_gfx", "SDL2/SDL2_imageFilter.h" = "libsdl2_gfx", "SDL2/SDL2_rotozoom.h" = "libsdl2_gfx"}
+library_names = {"SDL2/SDL_mixer.h" = "libsdl2_mixer", "SDL2/SDL_image.h" = "libsdl2_image", "SDL2/SDL_ttf.h" = "libsdl2_ttf", "SDL2/SDL2_framerate.h" = "libsdl2_gfx", "SDL2/SDL2_gfxPrimitives.h" = "libsdl2_gfx", "SDL2/SDL2_imageFilter.h" = "libsdl2_gfx", "SDL2/SDL2_rotozoom.h" = "libsdl2_gfx", "SDL2/SDL_net.h" = "libSDL2_net" }
 output_file_path = "../src/LibSDL2.jl"
 module_name = "LibSDL2"
 jll_pkg_name = "SDL2_jll"
-jll_pkg_extra = ["SDL2_mixer_jll", "SDL2_image_jll", "SDL2_ttf_jll", "SDL2_gfx_jll"]
+jll_pkg_extra = ["SDL2_mixer_jll", "SDL2_image_jll", "SDL2_ttf_jll", "SDL2_gfx_jll", "SDL2_net_jll"]
 export_symbol_prefixes = ["TTF_", "IMG_", "Mix_", "SDL_", "MIX_", "RW_", "AUDIO_", "KMOD_", "HAVE_", ]
 prologue_file_path = "./prologue.jl"
 use_deterministic_symbol = true
diff --git a/src/LibSDL2.jl b/src/LibSDL2.jl
index bec77de..55421b7 100644
--- a/src/LibSDL2.jl
+++ b/src/LibSDL2.jl
@@ -15,6 +15,9 @@ export SDL2_ttf_jll
 using SDL2_gfx_jll
 export SDL2_gfx_jll
 
+using SDL2_net_jll
+export SDL2_net_jll
+
 using CEnum
 
 const SDL_MIN_SINT8 = reinterpret(Int8, ~0x7F)
@@ -131,25 +134,25 @@ function SDL_UnlockMutex(mutex)
     ccall((:SDL_UnlockMutex, libsdl2), Cint, (Ptr{SDL_mutex},), mutex)
 end
 
-struct __JL_Ctag_559
+struct __JL_Ctag_648
     data::NTuple{24, UInt8}
 end
 
-function Base.getproperty(x::Ptr{__JL_Ctag_559}, f::Symbol)
-    f === :stdio && return Ptr{__JL_Ctag_560}(x + 0)
-    f === :mem && return Ptr{__JL_Ctag_561}(x + 0)
-    f === :unknown && return Ptr{__JL_Ctag_562}(x + 0)
+function Base.getproperty(x::Ptr{__JL_Ctag_648}, f::Symbol)
+    f === :stdio && return Ptr{__JL_Ctag_649}(x + 0)
+    f === :mem && return Ptr{__JL_Ctag_650}(x + 0)
+    f === :unknown && return Ptr{__JL_Ctag_651}(x + 0)
     return getfield(x, f)
 end
 
-function Base.getproperty(x::__JL_Ctag_559, f::Symbol)
-    r = Ref{__JL_Ctag_559}(x)
-    ptr = Base.unsafe_convert(Ptr{__JL_Ctag_559}, r)
+function Base.getproperty(x::__JL_Ctag_648, f::Symbol)
+    r = Ref{__JL_Ctag_648}(x)
+    ptr = Base.unsafe_convert(Ptr{__JL_Ctag_648}, r)
     fptr = getproperty(ptr, f)
     GC.@preserve r unsafe_load(fptr)
 end
 
-function Base.setproperty!(x::Ptr{__JL_Ctag_559}, f::Symbol, v)
+function Base.setproperty!(x::Ptr{__JL_Ctag_648}, f::Symbol, v)
     unsafe_store!(getproperty(x, f), v)
 end
 
@@ -164,7 +167,7 @@ function Base.getproperty(x::Ptr{SDL_RWops}, f::Symbol)
     f === :write && return Ptr{Ptr{Cvoid}}(x + 24)
     f === :close && return Ptr{Ptr{Cvoid}}(x + 32)
     f === :type && return Ptr{Uint32}(x + 40)
-    f === :hidden && return Ptr{__JL_Ctag_559}(x + 48)
+    f === :hidden && return Ptr{__JL_Ctag_648}(x + 48)
     return getfield(x, f)
 end
 
@@ -3530,25 +3533,25 @@ end
     SDL_CONTROLLER_BINDTYPE_HAT = 3
 end
 
-struct __JL_Ctag_563
+struct __JL_Ctag_652
     data::NTuple{8, UInt8}
 end
 
-function Base.getproperty(x::Ptr{__JL_Ctag_563}, f::Symbol)
+function Base.getproperty(x::Ptr{__JL_Ctag_652}, f::Symbol)
     f === :button && return Ptr{Cint}(x + 0)
     f === :axis && return Ptr{Cint}(x + 0)
-    f === :hat && return Ptr{__JL_Ctag_564}(x + 0)
+    f === :hat && return Ptr{__JL_Ctag_653}(x + 0)
     return getfield(x, f)
 end
 
-function Base.getproperty(x::__JL_Ctag_563, f::Symbol)
-    r = Ref{__JL_Ctag_563}(x)
-    ptr = Base.unsafe_convert(Ptr{__JL_Ctag_563}, r)
+function Base.getproperty(x::__JL_Ctag_652, f::Symbol)
+    r = Ref{__JL_Ctag_652}(x)
+    ptr = Base.unsafe_convert(Ptr{__JL_Ctag_652}, r)
     fptr = getproperty(ptr, f)
     GC.@preserve r unsafe_load(fptr)
 end
 
-function Base.setproperty!(x::Ptr{__JL_Ctag_563}, f::Symbol, v)
+function Base.setproperty!(x::Ptr{__JL_Ctag_652}, f::Symbol, v)
     unsafe_store!(getproperty(x, f), v)
 end
 
@@ -3558,7 +3561,7 @@ end
 
 function Base.getproperty(x::Ptr{SDL_GameControllerButtonBind}, f::Symbol)
     f === :bindType && return Ptr{SDL_GameControllerBindType}(x + 0)
-    f === :value && return Ptr{__JL_Ctag_563}(x + 4)
+    f === :value && return Ptr{__JL_Ctag_652}(x + 4)
     return getfield(x, f)
 end
 
@@ -6673,92 +6676,294 @@ function rotateSurface90Degrees(src, numClockwiseTurns)
     ccall((:rotateSurface90Degrees, libsdl2_gfx), Ptr{SDL_Surface}, (Ptr{SDL_Surface}, Cint), src, numClockwiseTurns)
 end
 
-struct __JL_Ctag_560
+struct _SDLNet_GenericSocket
+    ready::Cint
+end
+
+const SDLNet_GenericSocket = Ptr{_SDLNet_GenericSocket}
+
+function _SDLNet_SocketReady(sock)
+    ccall((:_SDLNet_SocketReady, libSDL2_net), Cint, (SDLNet_GenericSocket,), sock)
+end
+
+function _SDLNet_Write16(value, areap)
+    ccall((:_SDLNet_Write16, libSDL2_net), Cvoid, (Uint16, Ptr{Cvoid}), value, areap)
+end
+
+function _SDLNet_Write32(value, areap)
+    ccall((:_SDLNet_Write32, libSDL2_net), Cvoid, (Uint32, Ptr{Cvoid}), value, areap)
+end
+
+function _SDLNet_Read16(areap)
+    ccall((:_SDLNet_Read16, libSDL2_net), Uint16, (Ptr{Cvoid},), areap)
+end
+
+function _SDLNet_Read32(areap)
+    ccall((:_SDLNet_Read32, libSDL2_net), Uint32, (Ptr{Cvoid},), areap)
+end
+
+const SDLNet_version = SDL_version
+
+function SDLNet_Linked_Version()
+    ccall((:SDLNet_Linked_Version, libSDL2_net), Ptr{SDLNet_version}, ())
+end
+
+function SDLNet_Init()
+    ccall((:SDLNet_Init, libSDL2_net), Cint, ())
+end
+
+function SDLNet_Quit()
+    ccall((:SDLNet_Quit, libSDL2_net), Cvoid, ())
+end
+
+struct IPaddress
+    host::Uint32
+    port::Uint16
+end
+
+function SDLNet_ResolveHost(address, host, port)
+    ccall((:SDLNet_ResolveHost, libSDL2_net), Cint, (Ptr{IPaddress}, Ptr{Cchar}, Uint16), address, host, port)
+end
+
+function SDLNet_ResolveIP(ip)
+    ccall((:SDLNet_ResolveIP, libSDL2_net), Ptr{Cchar}, (Ptr{IPaddress},), ip)
+end
+
+function SDLNet_GetLocalAddresses(addresses, maxcount)
+    ccall((:SDLNet_GetLocalAddresses, libSDL2_net), Cint, (Ptr{IPaddress}, Cint), addresses, maxcount)
+end
+
+mutable struct _TCPsocket end
+
+const TCPsocket = Ptr{_TCPsocket}
+
+function SDLNet_TCP_Open(ip)
+    ccall((:SDLNet_TCP_Open, libSDL2_net), TCPsocket, (Ptr{IPaddress},), ip)
+end
+
+function SDLNet_TCP_Accept(server)
+    ccall((:SDLNet_TCP_Accept, libSDL2_net), TCPsocket, (TCPsocket,), server)
+end
+
+function SDLNet_TCP_GetPeerAddress(sock)
+    ccall((:SDLNet_TCP_GetPeerAddress, libSDL2_net), Ptr{IPaddress}, (TCPsocket,), sock)
+end
+
+function SDLNet_TCP_Send(sock, data, len)
+    ccall((:SDLNet_TCP_Send, libSDL2_net), Cint, (TCPsocket, Ptr{Cvoid}, Cint), sock, data, len)
+end
+
+function SDLNet_TCP_Recv(sock, data, maxlen)
+    ccall((:SDLNet_TCP_Recv, libSDL2_net), Cint, (TCPsocket, Ptr{Cvoid}, Cint), sock, data, maxlen)
+end
+
+function SDLNet_TCP_Close(sock)
+    ccall((:SDLNet_TCP_Close, libSDL2_net), Cvoid, (TCPsocket,), sock)
+end
+
+mutable struct _UDPsocket end
+
+const UDPsocket = Ptr{_UDPsocket}
+
+struct UDPpacket
+    channel::Cint
+    data::Ptr{Uint8}
+    len::Cint
+    maxlen::Cint
+    status::Cint
+    address::IPaddress
+end
+
+function SDLNet_AllocPacket(size)
+    ccall((:SDLNet_AllocPacket, libSDL2_net), Ptr{UDPpacket}, (Cint,), size)
+end
+
+function SDLNet_ResizePacket(packet, newsize)
+    ccall((:SDLNet_ResizePacket, libSDL2_net), Cint, (Ptr{UDPpacket}, Cint), packet, newsize)
+end
+
+function SDLNet_FreePacket(packet)
+    ccall((:SDLNet_FreePacket, libSDL2_net), Cvoid, (Ptr{UDPpacket},), packet)
+end
+
+function SDLNet_AllocPacketV(howmany, size)
+    ccall((:SDLNet_AllocPacketV, libSDL2_net), Ptr{Ptr{UDPpacket}}, (Cint, Cint), howmany, size)
+end
+
+function SDLNet_FreePacketV(packetV)
+    ccall((:SDLNet_FreePacketV, libSDL2_net), Cvoid, (Ptr{Ptr{UDPpacket}},), packetV)
+end
+
+function SDLNet_UDP_Open(port)
+    ccall((:SDLNet_UDP_Open, libSDL2_net), UDPsocket, (Uint16,), port)
+end
+
+function SDLNet_UDP_SetPacketLoss(sock, percent)
+    ccall((:SDLNet_UDP_SetPacketLoss, libSDL2_net), Cvoid, (UDPsocket, Cint), sock, percent)
+end
+
+function SDLNet_UDP_Bind(sock, channel, address)
+    ccall((:SDLNet_UDP_Bind, libSDL2_net), Cint, (UDPsocket, Cint, Ptr{IPaddress}), sock, channel, address)
+end
+
+function SDLNet_UDP_Unbind(sock, channel)
+    ccall((:SDLNet_UDP_Unbind, libSDL2_net), Cvoid, (UDPsocket, Cint), sock, channel)
+end
+
+function SDLNet_UDP_GetPeerAddress(sock, channel)
+    ccall((:SDLNet_UDP_GetPeerAddress, libSDL2_net), Ptr{IPaddress}, (UDPsocket, Cint), sock, channel)
+end
+
+function SDLNet_UDP_SendV(sock, packets, npackets)
+    ccall((:SDLNet_UDP_SendV, libSDL2_net), Cint, (UDPsocket, Ptr{Ptr{UDPpacket}}, Cint), sock, packets, npackets)
+end
+
+function SDLNet_UDP_Send(sock, channel, packet)
+    ccall((:SDLNet_UDP_Send, libSDL2_net), Cint, (UDPsocket, Cint, Ptr{UDPpacket}), sock, channel, packet)
+end
+
+function SDLNet_UDP_RecvV(sock, packets)
+    ccall((:SDLNet_UDP_RecvV, libSDL2_net), Cint, (UDPsocket, Ptr{Ptr{UDPpacket}}), sock, packets)
+end
+
+function SDLNet_UDP_Recv(sock, packet)
+    ccall((:SDLNet_UDP_Recv, libSDL2_net), Cint, (UDPsocket, Ptr{UDPpacket}), sock, packet)
+end
+
+function SDLNet_UDP_Close(sock)
+    ccall((:SDLNet_UDP_Close, libSDL2_net), Cvoid, (UDPsocket,), sock)
+end
+
+mutable struct _SDLNet_SocketSet end
+
+const SDLNet_SocketSet = Ptr{_SDLNet_SocketSet}
+
+function SDLNet_AllocSocketSet(maxsockets)
+    ccall((:SDLNet_AllocSocketSet, libSDL2_net), SDLNet_SocketSet, (Cint,), maxsockets)
+end
+
+function SDLNet_AddSocket(set, sock)
+    ccall((:SDLNet_AddSocket, libSDL2_net), Cint, (SDLNet_SocketSet, SDLNet_GenericSocket), set, sock)
+end
+
+function SDLNet_TCP_AddSocket(set, sock)
+    ccall((:SDLNet_TCP_AddSocket, libSDL2_net), Cint, (SDLNet_SocketSet, TCPsocket), set, sock)
+end
+
+function SDLNet_UDP_AddSocket(set, sock)
+    ccall((:SDLNet_UDP_AddSocket, libSDL2_net), Cint, (SDLNet_SocketSet, UDPsocket), set, sock)
+end
+
+function SDLNet_DelSocket(set, sock)
+    ccall((:SDLNet_DelSocket, libSDL2_net), Cint, (SDLNet_SocketSet, SDLNet_GenericSocket), set, sock)
+end
+
+function SDLNet_TCP_DelSocket(set, sock)
+    ccall((:SDLNet_TCP_DelSocket, libSDL2_net), Cint, (SDLNet_SocketSet, TCPsocket), set, sock)
+end
+
+function SDLNet_UDP_DelSocket(set, sock)
+    ccall((:SDLNet_UDP_DelSocket, libSDL2_net), Cint, (SDLNet_SocketSet, UDPsocket), set, sock)
+end
+
+function SDLNet_CheckSockets(set, timeout)
+    ccall((:SDLNet_CheckSockets, libSDL2_net), Cint, (SDLNet_SocketSet, Uint32), set, timeout)
+end
+
+function SDLNet_FreeSocketSet(set)
+    ccall((:SDLNet_FreeSocketSet, libSDL2_net), Cvoid, (SDLNet_SocketSet,), set)
+end
+
+function SDLNet_GetError()
+    ccall((:SDLNet_GetError, libSDL2_net), Ptr{Cchar}, ())
+end
+
+struct __JL_Ctag_649
     autoclose::SDL_bool
     fp::Ptr{Libc.FILE}
 end
-function Base.getproperty(x::Ptr{__JL_Ctag_560}, f::Symbol)
+function Base.getproperty(x::Ptr{__JL_Ctag_649}, f::Symbol)
     f === :autoclose && return Ptr{SDL_bool}(x + 0)
     f === :fp && return Ptr{Ptr{Libc.FILE}}(x + 8)
     return getfield(x, f)
 end
 
-function Base.getproperty(x::__JL_Ctag_560, f::Symbol)
-    r = Ref{__JL_Ctag_560}(x)
-    ptr = Base.unsafe_convert(Ptr{__JL_Ctag_560}, r)
+function Base.getproperty(x::__JL_Ctag_649, f::Symbol)
+    r = Ref{__JL_Ctag_649}(x)
+    ptr = Base.unsafe_convert(Ptr{__JL_Ctag_649}, r)
     fptr = getproperty(ptr, f)
     GC.@preserve r unsafe_load(fptr)
 end
 
-function Base.setproperty!(x::Ptr{__JL_Ctag_560}, f::Symbol, v)
+function Base.setproperty!(x::Ptr{__JL_Ctag_649}, f::Symbol, v)
     unsafe_store!(getproperty(x, f), v)
 end
 
 
-struct __JL_Ctag_561
+struct __JL_Ctag_650
     base::Ptr{Uint8}
     here::Ptr{Uint8}
     stop::Ptr{Uint8}
 end
-function Base.getproperty(x::Ptr{__JL_Ctag_561}, f::Symbol)
+function Base.getproperty(x::Ptr{__JL_Ctag_650}, f::Symbol)
     f === :base && return Ptr{Ptr{Uint8}}(x + 0)
     f === :here && return Ptr{Ptr{Uint8}}(x + 8)
     f === :stop && return Ptr{Ptr{Uint8}}(x + 16)
     return getfield(x, f)
 end
 
-function Base.getproperty(x::__JL_Ctag_561, f::Symbol)
-    r = Ref{__JL_Ctag_561}(x)
-    ptr = Base.unsafe_convert(Ptr{__JL_Ctag_561}, r)
+function Base.getproperty(x::__JL_Ctag_650, f::Symbol)
+    r = Ref{__JL_Ctag_650}(x)
+    ptr = Base.unsafe_convert(Ptr{__JL_Ctag_650}, r)
     fptr = getproperty(ptr, f)
     GC.@preserve r unsafe_load(fptr)
 end
 
-function Base.setproperty!(x::Ptr{__JL_Ctag_561}, f::Symbol, v)
+function Base.setproperty!(x::Ptr{__JL_Ctag_650}, f::Symbol, v)
     unsafe_store!(getproperty(x, f), v)
 end
 
 
-struct __JL_Ctag_562
+struct __JL_Ctag_651
     data1::Ptr{Cvoid}
     data2::Ptr{Cvoid}
 end
-function Base.getproperty(x::Ptr{__JL_Ctag_562}, f::Symbol)
+function Base.getproperty(x::Ptr{__JL_Ctag_651}, f::Symbol)
     f === :data1 && return Ptr{Ptr{Cvoid}}(x + 0)
     f === :data2 && return Ptr{Ptr{Cvoid}}(x + 8)
     return getfield(x, f)
 end
 
-function Base.getproperty(x::__JL_Ctag_562, f::Symbol)
-    r = Ref{__JL_Ctag_562}(x)
-    ptr = Base.unsafe_convert(Ptr{__JL_Ctag_562}, r)
+function Base.getproperty(x::__JL_Ctag_651, f::Symbol)
+    r = Ref{__JL_Ctag_651}(x)
+    ptr = Base.unsafe_convert(Ptr{__JL_Ctag_651}, r)
     fptr = getproperty(ptr, f)
     GC.@preserve r unsafe_load(fptr)
 end
 
-function Base.setproperty!(x::Ptr{__JL_Ctag_562}, f::Symbol, v)
+function Base.setproperty!(x::Ptr{__JL_Ctag_651}, f::Symbol, v)
     unsafe_store!(getproperty(x, f), v)
 end
 
 
-struct __JL_Ctag_564
+struct __JL_Ctag_653
     hat::Cint
     hat_mask::Cint
 end
-function Base.getproperty(x::Ptr{__JL_Ctag_564}, f::Symbol)
+function Base.getproperty(x::Ptr{__JL_Ctag_653}, f::Symbol)
     f === :hat && return Ptr{Cint}(x + 0)
     f === :hat_mask && return Ptr{Cint}(x + 4)
     return getfield(x, f)
 end
 
-function Base.getproperty(x::__JL_Ctag_564, f::Symbol)
-    r = Ref{__JL_Ctag_564}(x)
-    ptr = Base.unsafe_convert(Ptr{__JL_Ctag_564}, r)
+function Base.getproperty(x::__JL_Ctag_653, f::Symbol)
+    r = Ref{__JL_Ctag_653}(x)
+    ptr = Base.unsafe_convert(Ptr{__JL_Ctag_653}, r)
     fptr = getproperty(ptr, f)
     GC.@preserve r unsafe_load(fptr)
 end
 
-function Base.setproperty!(x::Ptr{__JL_Ctag_564}, f::Symbol, v)
+function Base.setproperty!(x::Ptr{__JL_Ctag_653}, f::Symbol, v)
     unsafe_store!(getproperty(x, f), v)
 end
 
@@ -7789,7 +7994,7 @@ const SDL2_GFXPRIMITIVES_MAJOR = 1
 
 const SDL2_GFXPRIMITIVES_MINOR = 0
 
-const SDL2_GFXPRIMITIVES_MICRO = 3
+const SDL2_GFXPRIMITIVES_MICRO = 4
 
 # Skipping MacroDefinition: SDL2_GFXPRIMITIVES_SCOPE extern
 
@@ -7801,8 +8006,30 @@ const SMOOTHING_ON = 1
 
 # Skipping MacroDefinition: SDL2_ROTOZOOM_SCOPE extern
 
+const SDL_NET_MAJOR_VERSION = 2
+
+const SDL_NET_MINOR_VERSION = 2
+
+const SDL_NET_PATCHLEVEL = 0
+
+const SDL_NET_COMPILEDVERSION = SDL_VERSIONNUM(SDL_NET_MAJOR_VERSION, SDL_NET_MINOR_VERSION, SDL_NET_PATCHLEVEL)
+
+const INADDR_ANY = 0x00000000
+
+const INADDR_NONE = 0xffffffff
+
+const INADDR_LOOPBACK = 0x7f000001
+
+const INADDR_BROADCAST = 0xffffffff
+
+const SDLNET_MAX_UDPCHANNELS = 32
+
+const SDLNET_MAX_UDPADDRESSES = 4
+
+const SDL_DATA_ALIGNED = 0
+
 # exports
-const PREFIXES = ["TTF_", "IMG_", "Mix_", "SDL_", "MIX_", "RW_", "AUDIO_", "KMOD_", "HAVE_"]
+const PREFIXES = ["TTF_", "IMG_", "Mix_", "SDL_", "MIX_", "RW_", "AUDIO_", "KMOD_", "HAVE_", "SDLNet_"]
 for name in names(@__MODULE__; all=true), prefix in PREFIXES
     if startswith(string(name), prefix)
         @eval export $name
diff --git a/test/lib/SDL_net.jl b/test/lib/SDL_net.jl
new file mode 100644
index 0000000..b240332
--- /dev/null
+++ b/test/lib/SDL_net.jl
@@ -0,0 +1,57 @@
+using Test
+
+@testset "SDL_net" begin
+    @test SDLNet_Init() == 0  # Ensure SDL_net initializes successfully
+
+    # Set up server
+    server_ip = Ref(LibSDL2.IPaddress(0, 0))
+    @test SDLNet_ResolveHost(server_ip, C_NULL, 12345) == 0  # Check if resolving the host succeeds
+
+    server_socket = SDLNet_TCP_Open(server_ip)
+    @test server_socket != C_NULL  # Verify that server socket is successfully opened
+
+    @debug("Server is running on port 12345...")
+
+    # Set up client
+    client_ip = Ref(LibSDL2.IPaddress(0, 0))
+    @test SDLNet_ResolveHost(client_ip, pointer("127.0.0.1"), 12345) == 0  # Ensure client resolves host
+
+    client_socket = SDLNet_TCP_Open(client_ip)
+    @test client_socket != C_NULL  # Verify that client socket is successfully opened
+
+    @debug("Client connected to server.")
+
+    # Accept client connection on server side
+    server_client_socket = SDLNet_TCP_Accept(server_socket)
+    @test server_client_socket != C_NULL  # Ensure server accepts the connection
+
+    @debug("Server accepted client connection.")
+
+    # Send message from client to server
+    message = "Hello, server!"
+    message_ptr = pointer(message)
+    bytes_sent = SDLNet_TCP_Send(client_socket, message_ptr, sizeof(message))
+    @test bytes_sent > 0  # Ensure message is sent successfully
+
+    @debug("Client sent message: ", message)
+
+    # Receive message on server side
+    buffer = Vector{UInt8}(undef, 256)
+    bytes_received = SDLNet_TCP_Recv(server_client_socket, pointer(buffer), 256)
+    @test bytes_received > 0  # Ensure data is received
+
+    if bytes_received > 0
+        received_message = unsafe_string(pointer(buffer))
+        @debug("Server received message: ", received_message)
+        @test received_message[1:bytes_received] == message  # Check if message matches
+    else
+        @debug("No message received.")
+    end
+
+    # Cleanup
+    SDLNet_TCP_Close(client_socket)
+    SDLNet_TCP_Close(server_client_socket)
+    SDLNet_TCP_Close(server_socket)
+
+    @test SDLNet_Quit() === nothing  # Verify SDLNet_Quit() executes without errors
+end
diff --git a/test/runtests.jl b/test/runtests.jl
index 58ec6aa..f916721 100644
--- a/test/runtests.jl
+++ b/test/runtests.jl
@@ -8,4 +8,5 @@ include("lib/SDL_image.jl")
 include("lib/SDL_ttf.jl")
 include("lib/SDL_mixer.jl")
 include("lib/SDL_gfx.jl")
+include("lib/SDL_net.jl")