diff --git a/Cargo.lock b/Cargo.lock
index 4687b855..fec18887 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -87,6 +87,9 @@ name = "bitflags"
 version = "2.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "812e12b5285cc515a9c72a5c1d3b6d46a19dac5acfef5265968c166106e31dd3"
+dependencies = [
+ "serde_core",
+]
 
 [[package]]
 name = "bumpalo"
@@ -669,6 +672,7 @@ dependencies = [
 name = "notify-types"
 version = "2.0.0"
 dependencies = [
+ "bitflags 2.10.0",
  "insta",
  "rstest",
  "serde",
diff --git a/examples/debouncer_full.rs b/examples/debouncer_full.rs
index e2ec9e33..7f799258 100644
--- a/examples/debouncer_full.rs
+++ b/examples/debouncer_full.rs
@@ -1,10 +1,14 @@
 use std::{fs, thread, time::Duration};
 
-use notify::RecursiveMode;
-use notify_debouncer_full::new_debouncer;
+use notify::{EventKindMask, RecommendedWatcher, RecursiveMode};
+use notify_debouncer_full::{new_debouncer_opt, notify, RecommendedCache};
 use tempfile::tempdir;
 
-/// Advanced example of the notify-debouncer-full, accessing the internal file ID cache
+/// Advanced example of the notify-debouncer-full with event filtering.
+///
+/// This demonstrates using new_debouncer_opt() to pass a custom notify::Config
+/// that filters events at the kernel level (on Linux), reducing noise and
+/// improving performance.
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     let dir = tempdir()?;
     let dir_path = dir.path().to_path_buf();
@@ -25,11 +29,21 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         }
     });
 
-    // setup debouncer
+    // setup debouncer with custom event filtering
     let (tx, rx) = std::sync::mpsc::channel();
 
-    // no specific tickrate, max debounce time 2 seconds
-    let mut debouncer = new_debouncer(Duration::from_secs(2), None, tx)?;
+    // Configure notify to exclude noisy access events (OPEN/CLOSE)
+    // Use CORE mask: CREATE, REMOVE, MODIFY_DATA, MODIFY_META, MODIFY_NAME
+    let notify_config = notify::Config::default().with_event_kinds(EventKindMask::CORE);
+
+    // Use new_debouncer_opt for full control over the watcher configuration
+    let mut debouncer = new_debouncer_opt::<_, RecommendedWatcher, RecommendedCache>(
+        Duration::from_secs(2), // debounce timeout
+        None,                   // tick rate (None = auto)
+        tx,
+        RecommendedCache::new(),
+        notify_config,
+    )?;
 
     debouncer.watch(dir.path(), RecursiveMode::Recursive)?;
 
diff --git a/examples/debouncer_mini.rs b/examples/debouncer_mini.rs
index bff178a6..c7e69de4 100644
--- a/examples/debouncer_mini.rs
+++ b/examples/debouncer_mini.rs
@@ -1,9 +1,12 @@
 use std::{path::Path, time::Duration};
 
-use notify::RecursiveMode;
-use notify_debouncer_mini::new_debouncer;
+use notify::{EventKindMask, RecommendedWatcher, RecursiveMode};
+use notify_debouncer_mini::{new_debouncer_opt, Config};
 
-/// Example for debouncer mini
+/// Example for debouncer mini with event filtering.
+///
+/// This demonstrates using Config::with_notify_config() to pass a custom notify::Config
+/// that filters events at the kernel level (on Linux), reducing noise.
 fn main() {
     env_logger::Builder::from_env(
         env_logger::Env::default().default_filter_or("debouncer_mini=trace"),
@@ -29,11 +32,16 @@ fn main() {
         }
     });
 
-    // setup debouncer
+    // setup debouncer with custom event filtering
     let (tx, rx) = std::sync::mpsc::channel();
 
-    // No specific tickrate, max debounce time 1 seconds
-    let mut debouncer = new_debouncer(Duration::from_secs(1), tx).unwrap();
+    // Configure debouncer with notify config that excludes access events
+    // CORE mask: CREATE, REMOVE, MODIFY_DATA, MODIFY_META, MODIFY_NAME
+    let config = Config::default()
+        .with_timeout(Duration::from_secs(1))
+        .with_notify_config(notify::Config::default().with_event_kinds(EventKindMask::CORE));
+
+    let mut debouncer = new_debouncer_opt::<_, RecommendedWatcher>(config, tx).unwrap();
 
     debouncer
         .watcher()
diff --git a/examples/event_filtering.rs b/examples/event_filtering.rs
new file mode 100644
index 00000000..73ce70c4
--- /dev/null
+++ b/examples/event_filtering.rs
@@ -0,0 +1,105 @@
+/// Example demonstrating EventKindMask for filtering filesystem events.
+///
+/// EventKindMask allows you to configure which types of events you want to receive,
+/// reducing noise and improving performance by filtering at the kernel level (on Linux).
+///
+/// Run with: cargo run --example event_filtering -- <path>
+use notify::{Config, EventKindMask, RecommendedWatcher, RecursiveMode, Watcher};
+use std::path::Path;
+
+fn main() {
+    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();
+
+    let path = std::env::args()
+        .nth(1)
+        .expect("Argument 1 needs to be a path");
+
+    log::info!("Watching {path}");
+
+    // Choose which event filtering mode to demonstrate
+    let mode = std::env::args().nth(2).unwrap_or_default();
+    let result = match mode.as_str() {
+        "core" => {
+            log::info!("Mode: CORE (excludes access events like OPEN/CLOSE)");
+            watch_core(&path)
+        }
+        "create-remove" => {
+            log::info!("Mode: CREATE | REMOVE only");
+            watch_create_remove(&path)
+        }
+        _ => {
+            log::info!("Mode: ALL (default, receives all events)");
+            log::info!("  Use 'core' or 'create-remove' as 2nd arg for other modes");
+            watch_all(&path)
+        }
+    };
+
+    if let Err(error) = result {
+        log::error!("Error: {error:?}");
+    }
+}
+
+/// Watch with ALL events (default behavior, backward compatible)
+fn watch_all<P: AsRef<Path>>(path: P) -> notify::Result<()> {
+    let (tx, rx) = std::sync::mpsc::channel();
+
+    // Default config receives all events including access events (OPEN, CLOSE)
+    let config = Config::default();
+    // Equivalent to: Config::default().with_event_kinds(EventKindMask::ALL)
+
+    let mut watcher = RecommendedWatcher::new(tx, config)?;
+    watcher.watch(path.as_ref(), RecursiveMode::Recursive)?;
+
+    for res in rx {
+        match res {
+            Ok(event) => log::info!("Event: {event:?}"),
+            Err(error) => log::error!("Error: {error:?}"),
+        }
+    }
+
+    Ok(())
+}
+
+/// Watch with CORE events only (excludes noisy access events)
+///
+/// CORE includes: CREATE, REMOVE, MODIFY_DATA, MODIFY_META, MODIFY_NAME
+/// Excludes: ACCESS_OPEN, ACCESS_CLOSE, ACCESS_CLOSE_NOWRITE
+fn watch_core<P: AsRef<Path>>(path: P) -> notify::Result<()> {
+    let (tx, rx) = std::sync::mpsc::channel();
+
+    // CORE mask excludes access events, reducing noise significantly
+    let config = Config::default().with_event_kinds(EventKindMask::CORE);
+
+    let mut watcher = RecommendedWatcher::new(tx, config)?;
+    watcher.watch(path.as_ref(), RecursiveMode::Recursive)?;
+
+    for res in rx {
+        match res {
+            Ok(event) => log::info!("Event: {event:?}"),
+            Err(error) => log::error!("Error: {error:?}"),
+        }
+    }
+
+    Ok(())
+}
+
+/// Watch only file creation and removal events
+fn watch_create_remove<P: AsRef<Path>>(path: P) -> notify::Result<()> {
+    let (tx, rx) = std::sync::mpsc::channel();
+
+    // Custom mask: only CREATE and REMOVE events
+    let config =
+        Config::default().with_event_kinds(EventKindMask::CREATE | EventKindMask::REMOVE);
+
+    let mut watcher = RecommendedWatcher::new(tx, config)?;
+    watcher.watch(path.as_ref(), RecursiveMode::Recursive)?;
+
+    for res in rx {
+        match res {
+            Ok(event) => log::info!("Event: {event:?}"),
+            Err(error) => log::error!("Error: {error:?}"),
+        }
+    }
+
+    Ok(())
+}
diff --git a/notify-types/Cargo.toml b/notify-types/Cargo.toml
index 3e41283b..f5e3c3c9 100644
--- a/notify-types/Cargo.toml
+++ b/notify-types/Cargo.toml
@@ -15,8 +15,10 @@ repository.workspace = true
 
 [features]
 serialization-compat-6 = []
+serde = ["dep:serde", "bitflags/serde"]
 
 [dependencies]
+bitflags = "2"
 serde = { workspace = true, optional = true }
 web-time = { workspace = true, optional = true }
 
diff --git a/notify-types/src/event.rs b/notify-types/src/event.rs
index 9e1f3dec..5c77c138 100644
--- a/notify-types/src/event.rs
+++ b/notify-types/src/event.rs
@@ -6,6 +6,8 @@ use std::{
     path::PathBuf,
 };
 
+use bitflags::bitflags;
+
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
@@ -272,6 +274,144 @@ impl EventKind {
     }
 }
 
+bitflags! {
+    /// A bitmask specifying which event kinds to monitor.
+    ///
+    /// This type allows fine-grained control over which filesystem events are reported.
+    /// On backends that support kernel-level filtering (inotify), the mask is
+    /// translated to native flags for optimal performance. On other backends (kqueue,
+    /// Windows, FSEvents, PollWatcher), filtering is applied in userspace.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use notify_types::event::EventKindMask;
+    ///
+    /// // Monitor only file creations and deletions
+    /// let mask = EventKindMask::CREATE | EventKindMask::REMOVE;
+    ///
+    /// // Monitor everything including access events
+    /// let all = EventKindMask::ALL;
+    ///
+    /// // Default: includes all events (matches Config::default())
+    /// let default = EventKindMask::default();
+    /// assert_eq!(default, EventKindMask::ALL);
+    /// ```
+    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+    pub struct EventKindMask: u32 {
+        /// Monitor file/folder creation events.
+        const CREATE = 0b0000_0001;
+
+        /// Monitor file/folder removal events.
+        const REMOVE = 0b0000_0010;
+
+        /// Monitor data modification events (content/size changes).
+        const MODIFY_DATA = 0b0000_0100;
+
+        /// Monitor metadata modification events (permissions, timestamps, etc).
+        const MODIFY_META = 0b0000_1000;
+
+        /// Monitor name/rename events.
+        const MODIFY_NAME = 0b0001_0000;
+
+        /// Monitor file open events.
+        const ACCESS_OPEN = 0b0010_0000;
+
+        /// Monitor file close events after writing.
+        /// This fires when a file opened for writing is closed.
+        const ACCESS_CLOSE = 0b0100_0000;
+
+        /// Monitor file close events after read-only access.
+        /// This fires when a file opened for reading (not writing) is closed.
+        /// Note: This can be very noisy and may cause queue overflow on busy systems.
+        const ACCESS_CLOSE_NOWRITE = 0b1000_0000;
+
+        /// All modify events (data, metadata, and name changes).
+        const ALL_MODIFY = Self::MODIFY_DATA.bits() | Self::MODIFY_META.bits() | Self::MODIFY_NAME.bits();
+
+        /// All access events (open, close-write, and close-nowrite).
+        const ALL_ACCESS = Self::ACCESS_OPEN.bits() | Self::ACCESS_CLOSE.bits() | Self::ACCESS_CLOSE_NOWRITE.bits();
+
+        /// Core events: create, remove, and all modify events.
+        /// This is the default and matches the current notify behavior (no access events).
+        const CORE = Self::CREATE.bits() | Self::REMOVE.bits() | Self::ALL_MODIFY.bits();
+
+        /// All events including access events.
+        const ALL = Self::CORE.bits() | Self::ALL_ACCESS.bits();
+    }
+}
+
+impl Default for EventKindMask {
+    fn default() -> Self {
+        EventKindMask::ALL
+    }
+}
+
+impl EventKindMask {
+    /// Returns whether the given event kind matches this mask.
+    ///
+    /// `EventKind::Any` and `EventKind::Other` always pass regardless of the mask,
+    /// as they represent meta-events that should not be filtered.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use notify_types::event::{EventKindMask, EventKind, CreateKind, AccessKind, AccessMode};
+    ///
+    /// let mask = EventKindMask::CREATE;
+    /// assert!(mask.matches(&EventKind::Create(CreateKind::File)));
+    /// assert!(!mask.matches(&EventKind::Access(AccessKind::Open(AccessMode::Read))));
+    ///
+    /// // Any and Other always pass
+    /// let empty = EventKindMask::empty();
+    /// assert!(empty.matches(&EventKind::Any));
+    /// assert!(empty.matches(&EventKind::Other));
+    /// ```
+    pub fn matches(&self, kind: &EventKind) -> bool {
+        match kind {
+            // Meta-events always pass
+            EventKind::Any | EventKind::Other => true,
+
+            // Create events
+            EventKind::Create(_) => self.intersects(EventKindMask::CREATE),
+
+            // Remove events
+            EventKind::Remove(_) => self.intersects(EventKindMask::REMOVE),
+
+            // Modify events - check subkind
+            EventKind::Modify(modify_kind) => match modify_kind {
+                ModifyKind::Data(_) => self.intersects(EventKindMask::MODIFY_DATA),
+                ModifyKind::Metadata(_) => self.intersects(EventKindMask::MODIFY_META),
+                ModifyKind::Name(_) => self.intersects(EventKindMask::MODIFY_NAME),
+                // ModifyKind::Any and ModifyKind::Other pass if any modify flag is set
+                ModifyKind::Any | ModifyKind::Other => self.intersects(EventKindMask::ALL_MODIFY),
+            },
+
+            // Access events - check subkind
+            EventKind::Access(access_kind) => match access_kind {
+                AccessKind::Open(_) => self.intersects(EventKindMask::ACCESS_OPEN),
+                // Close after write
+                AccessKind::Close(AccessMode::Write) => {
+                    self.intersects(EventKindMask::ACCESS_CLOSE)
+                }
+                // Close after read-only (no write)
+                AccessKind::Close(AccessMode::Read) => {
+                    self.intersects(EventKindMask::ACCESS_CLOSE_NOWRITE)
+                }
+                // Close with unknown mode - match if either close flag is set
+                AccessKind::Close(_) => {
+                    self.intersects(EventKindMask::ACCESS_CLOSE | EventKindMask::ACCESS_CLOSE_NOWRITE)
+                }
+                // AccessKind::Read, Any, and Other pass if any access flag is set
+                AccessKind::Read | AccessKind::Any | AccessKind::Other => {
+                    self.intersects(EventKindMask::ALL_ACCESS)
+                }
+            },
+        }
+    }
+}
+
 /// Notify event.
 ///
 /// You might want to check [`Event::need_rescan`] to make sure no event was missed before you
@@ -629,6 +769,183 @@ impl Hash for Event {
     }
 }
 
+#[cfg(test)]
+mod event_kind_mask_tests {
+    use super::*;
+
+    #[test]
+    fn default_is_all() {
+        assert_eq!(EventKindMask::default(), EventKindMask::ALL);
+    }
+
+    #[test]
+    fn matches_create_events() {
+        let mask = EventKindMask::CREATE;
+        assert!(mask.matches(&EventKind::Create(CreateKind::File)));
+        assert!(mask.matches(&EventKind::Create(CreateKind::Folder)));
+        assert!(mask.matches(&EventKind::Create(CreateKind::Any)));
+        assert!(mask.matches(&EventKind::Create(CreateKind::Other)));
+        assert!(!mask.matches(&EventKind::Remove(RemoveKind::File)));
+    }
+
+    #[test]
+    fn matches_remove_events() {
+        let mask = EventKindMask::REMOVE;
+        assert!(mask.matches(&EventKind::Remove(RemoveKind::File)));
+        assert!(mask.matches(&EventKind::Remove(RemoveKind::Folder)));
+        assert!(mask.matches(&EventKind::Remove(RemoveKind::Any)));
+        assert!(!mask.matches(&EventKind::Create(CreateKind::File)));
+    }
+
+    #[test]
+    fn matches_access_open_events() {
+        let mask = EventKindMask::ACCESS_OPEN;
+        assert!(mask.matches(&EventKind::Access(AccessKind::Open(AccessMode::Any))));
+        assert!(mask.matches(&EventKind::Access(AccessKind::Open(AccessMode::Read))));
+        assert!(mask.matches(&EventKind::Access(AccessKind::Open(AccessMode::Write))));
+        assert!(!mask.matches(&EventKind::Access(AccessKind::Close(AccessMode::Write))));
+        assert!(!mask.matches(&EventKind::Create(CreateKind::File)));
+    }
+
+    #[test]
+    fn matches_access_close_events() {
+        // ACCESS_CLOSE only matches Close(Write), not Close(Read)
+        let mask = EventKindMask::ACCESS_CLOSE;
+        assert!(mask.matches(&EventKind::Access(AccessKind::Close(AccessMode::Write))));
+        assert!(mask.matches(&EventKind::Access(AccessKind::Close(AccessMode::Any)))); // Any could be write
+        assert!(!mask.matches(&EventKind::Access(AccessKind::Close(AccessMode::Read)))); // Read goes to NOWRITE
+        assert!(!mask.matches(&EventKind::Access(AccessKind::Open(AccessMode::Any))));
+    }
+
+    #[test]
+    fn matches_access_close_nowrite_events() {
+        // ACCESS_CLOSE_NOWRITE matches Close(Read) - files opened read-only
+        let mask = EventKindMask::ACCESS_CLOSE_NOWRITE;
+        assert!(mask.matches(&EventKind::Access(AccessKind::Close(AccessMode::Read))));
+        assert!(mask.matches(&EventKind::Access(AccessKind::Close(AccessMode::Any)))); // Any could be read
+        assert!(!mask.matches(&EventKind::Access(AccessKind::Close(AccessMode::Write)))); // Write goes to ACCESS_CLOSE
+        assert!(!mask.matches(&EventKind::Access(AccessKind::Open(AccessMode::Any))));
+    }
+
+    #[test]
+    fn combined_close_masks_match_both() {
+        // When both ACCESS_CLOSE and ACCESS_CLOSE_NOWRITE are set, match both
+        let mask = EventKindMask::ACCESS_CLOSE | EventKindMask::ACCESS_CLOSE_NOWRITE;
+        assert!(mask.matches(&EventKind::Access(AccessKind::Close(AccessMode::Write))));
+        assert!(mask.matches(&EventKind::Access(AccessKind::Close(AccessMode::Read))));
+        assert!(mask.matches(&EventKind::Access(AccessKind::Close(AccessMode::Any))));
+    }
+
+    #[test]
+    fn all_access_matches_open_close_read_any_other() {
+        let mask = EventKindMask::ALL_ACCESS;
+        assert!(mask.matches(&EventKind::Access(AccessKind::Open(AccessMode::Read))));
+        assert!(mask.matches(&EventKind::Access(AccessKind::Close(AccessMode::Write))));
+        assert!(mask.matches(&EventKind::Access(AccessKind::Read)));
+        assert!(mask.matches(&EventKind::Access(AccessKind::Any)));
+        assert!(mask.matches(&EventKind::Access(AccessKind::Other)));
+    }
+
+    #[test]
+    fn matches_modify_data_events() {
+        let mask = EventKindMask::MODIFY_DATA;
+        assert!(mask.matches(&EventKind::Modify(ModifyKind::Data(DataChange::Any))));
+        assert!(mask.matches(&EventKind::Modify(ModifyKind::Data(DataChange::Size))));
+        assert!(mask.matches(&EventKind::Modify(ModifyKind::Data(DataChange::Content))));
+        assert!(!mask.matches(&EventKind::Modify(ModifyKind::Metadata(MetadataKind::Any))));
+        assert!(!mask.matches(&EventKind::Modify(ModifyKind::Name(RenameMode::From))));
+    }
+
+    #[test]
+    fn matches_modify_metadata_events() {
+        let mask = EventKindMask::MODIFY_META;
+        assert!(mask.matches(&EventKind::Modify(ModifyKind::Metadata(MetadataKind::Any))));
+        assert!(mask.matches(&EventKind::Modify(ModifyKind::Metadata(
+            MetadataKind::Permissions
+        ))));
+        assert!(!mask.matches(&EventKind::Modify(ModifyKind::Data(DataChange::Any))));
+    }
+
+    #[test]
+    fn matches_modify_name_events() {
+        let mask = EventKindMask::MODIFY_NAME;
+        assert!(mask.matches(&EventKind::Modify(ModifyKind::Name(RenameMode::From))));
+        assert!(mask.matches(&EventKind::Modify(ModifyKind::Name(RenameMode::To))));
+        assert!(mask.matches(&EventKind::Modify(ModifyKind::Name(RenameMode::Both))));
+        assert!(!mask.matches(&EventKind::Modify(ModifyKind::Data(DataChange::Any))));
+    }
+
+    #[test]
+    fn all_modify_matches_data_meta_name() {
+        let mask = EventKindMask::ALL_MODIFY;
+        assert!(mask.matches(&EventKind::Modify(ModifyKind::Data(DataChange::Any))));
+        assert!(mask.matches(&EventKind::Modify(ModifyKind::Metadata(MetadataKind::Any))));
+        assert!(mask.matches(&EventKind::Modify(ModifyKind::Name(RenameMode::From))));
+        assert!(mask.matches(&EventKind::Modify(ModifyKind::Any)));
+        assert!(mask.matches(&EventKind::Modify(ModifyKind::Other)));
+    }
+
+    #[test]
+    fn any_and_other_always_pass() {
+        let empty = EventKindMask::empty();
+        assert!(empty.matches(&EventKind::Any));
+        assert!(empty.matches(&EventKind::Other));
+    }
+
+    #[test]
+    fn core_excludes_access() {
+        let core = EventKindMask::CORE;
+        assert!(core.matches(&EventKind::Create(CreateKind::File)));
+        assert!(core.matches(&EventKind::Remove(RemoveKind::File)));
+        assert!(core.matches(&EventKind::Modify(ModifyKind::Data(DataChange::Any))));
+        assert!(core.matches(&EventKind::Modify(ModifyKind::Metadata(MetadataKind::Any))));
+        assert!(core.matches(&EventKind::Modify(ModifyKind::Name(RenameMode::From))));
+        assert!(!core.matches(&EventKind::Access(AccessKind::Open(AccessMode::Any))));
+        assert!(!core.matches(&EventKind::Access(AccessKind::Close(AccessMode::Write))));
+    }
+
+    #[test]
+    fn empty_mask_only_passes_any_other() {
+        let empty = EventKindMask::empty();
+        assert!(empty.matches(&EventKind::Any));
+        assert!(empty.matches(&EventKind::Other));
+        assert!(!empty.matches(&EventKind::Create(CreateKind::File)));
+        assert!(!empty.matches(&EventKind::Remove(RemoveKind::File)));
+        assert!(!empty.matches(&EventKind::Modify(ModifyKind::Data(DataChange::Any))));
+        assert!(!empty.matches(&EventKind::Access(AccessKind::Open(AccessMode::Any))));
+    }
+
+    #[test]
+    fn bitwise_or_combines_masks() {
+        let mask = EventKindMask::CREATE | EventKindMask::REMOVE;
+        assert!(mask.matches(&EventKind::Create(CreateKind::File)));
+        assert!(mask.matches(&EventKind::Remove(RemoveKind::Folder)));
+        assert!(!mask.matches(&EventKind::Modify(ModifyKind::Data(DataChange::Any))));
+        assert!(!mask.matches(&EventKind::Access(AccessKind::Open(AccessMode::Any))));
+    }
+
+    #[test]
+    fn all_matches_everything() {
+        let all = EventKindMask::ALL;
+        assert!(all.matches(&EventKind::Any));
+        assert!(all.matches(&EventKind::Other));
+        assert!(all.matches(&EventKind::Create(CreateKind::File)));
+        assert!(all.matches(&EventKind::Remove(RemoveKind::File)));
+        assert!(all.matches(&EventKind::Modify(ModifyKind::Data(DataChange::Any))));
+        assert!(all.matches(&EventKind::Access(AccessKind::Open(AccessMode::Any))));
+        assert!(all.matches(&EventKind::Access(AccessKind::Close(AccessMode::Write))));
+    }
+
+    #[test]
+    fn access_read_and_any_match_with_all_access() {
+        // Edge case: AccessKind::Read and AccessKind::Any should match if ALL_ACCESS is set
+        let mask = EventKindMask::ALL_ACCESS;
+        assert!(mask.matches(&EventKind::Access(AccessKind::Read)));
+        assert!(mask.matches(&EventKind::Access(AccessKind::Any)));
+        assert!(mask.matches(&EventKind::Access(AccessKind::Other)));
+    }
+}
+
 #[cfg(all(test, feature = "serde", not(feature = "serialization-compat-6")))]
 mod tests {
     use super::*;
diff --git a/notify-types/src/lib.rs b/notify-types/src/lib.rs
index 11f7cd21..2a743d4d 100644
--- a/notify-types/src/lib.rs
+++ b/notify-types/src/lib.rs
@@ -28,6 +28,7 @@ mod tests {
         assert_debug_impl!(event::RenameMode);
         assert_debug_impl!(event::Event);
         assert_debug_impl!(event::EventKind);
+        assert_debug_impl!(event::EventKindMask);
         assert_debug_impl!(debouncer_mini::DebouncedEvent);
         assert_debug_impl!(debouncer_mini::DebouncedEventKind);
         assert_debug_impl!(debouncer_full::DebouncedEvent);
diff --git a/notify/src/config.rs b/notify/src/config.rs
index cc65c65f..fe0888d0 100644
--- a/notify/src/config.rs
+++ b/notify/src/config.rs
@@ -1,5 +1,6 @@
 //! Configuration types
 
+use notify_types::event::EventKindMask;
 use std::time::Duration;
 
 /// Indicates whether only the provided directory or its sub-directories as well should be watched
@@ -44,6 +45,9 @@ pub struct Config {
     compare_contents: bool,
 
     follow_symlinks: bool,
+
+    /// See [Config::with_event_kinds]
+    event_kinds: EventKindMask,
 }
 
 impl Config {
@@ -112,6 +116,42 @@ impl Config {
     pub fn follow_symlinks(&self) -> bool {
         self.follow_symlinks
     }
+
+    /// Filter which event kinds are monitored.
+    ///
+    /// This allows you to control which types of filesystem events are delivered
+    /// to your event handler. On backends that support kernel-level filtering
+    /// (inotify), the mask is translated to native flags for optimal
+    /// performance. On other backends (kqueue, Windows, FSEvents, PollWatcher),
+    /// filtering is applied in userspace.
+    ///
+    /// The default is [`EventKindMask::ALL`], which includes all events.
+    /// Use [`EventKindMask::CORE`] to exclude access events.
+    ///
+    /// This can't be changed during runtime.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use notify::{Config, EventKindMask};
+    ///
+    /// // Only monitor file creation and deletion
+    /// let config = Config::default()
+    ///     .with_event_kinds(EventKindMask::CREATE | EventKindMask::REMOVE);
+    ///
+    /// // Monitor everything including access events
+    /// let config_all = Config::default()
+    ///     .with_event_kinds(EventKindMask::ALL);
+    /// ```
+    pub fn with_event_kinds(mut self, event_kinds: EventKindMask) -> Self {
+        self.event_kinds = event_kinds;
+        self
+    }
+
+    /// Returns current setting
+    pub fn event_kinds(&self) -> EventKindMask {
+        self.event_kinds
+    }
 }
 
 impl Default for Config {
@@ -120,6 +160,45 @@ impl Default for Config {
             poll_interval: Some(Duration::from_secs(30)),
             compare_contents: false,
             follow_symlinks: true,
+            event_kinds: EventKindMask::ALL,
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use notify_types::event::EventKindMask;
+
+    #[test]
+    fn config_default_event_kinds_is_all() {
+        let config = Config::default();
+        assert_eq!(config.event_kinds(), EventKindMask::ALL);
+    }
+
+    #[test]
+    fn config_with_event_kinds() {
+        let mask = EventKindMask::CREATE | EventKindMask::REMOVE;
+        let config = Config::default().with_event_kinds(mask);
+        assert_eq!(config.event_kinds(), mask);
+    }
+
+    #[test]
+    fn config_with_all_events_includes_access() {
+        let config = Config::default().with_event_kinds(EventKindMask::ALL);
+        assert!(config.event_kinds().intersects(EventKindMask::ALL_ACCESS));
+    }
+
+    #[test]
+    fn config_with_empty_mask() {
+        let config = Config::default().with_event_kinds(EventKindMask::empty());
+        assert!(config.event_kinds().is_empty());
+    }
+
+    #[test]
+    fn event_kind_mask_default_matches_config_default() {
+        // Verify cross-crate consistency: both defaults should be ALL
+        assert_eq!(EventKindMask::default(), Config::default().event_kinds());
+        assert_eq!(EventKindMask::default(), EventKindMask::ALL);
+    }
+}
diff --git a/notify/src/fsevent.rs b/notify/src/fsevent.rs
index 5b79b2fa..32f06d7d 100644
--- a/notify/src/fsevent.rs
+++ b/notify/src/fsevent.rs
@@ -16,7 +16,8 @@
 
 use crate::event::*;
 use crate::{
-    unbounded, Config, Error, EventHandler, PathsMut, RecursiveMode, Result, Sender, Watcher,
+    unbounded, Config, Error, EventHandler, EventKindMask, PathsMut, RecursiveMode, Result, Sender,
+    Watcher,
 };
 use fsevent_sys as fs;
 use fsevent_sys::core_foundation as cf;
@@ -69,6 +70,7 @@ pub struct FsEventWatcher {
     event_handler: Arc<Mutex<dyn EventHandler>>,
     runloop: Option<(cf::CFRunLoopRef, thread::JoinHandle<()>)>,
     recursive_info: HashMap<PathBuf, bool>,
+    event_kinds: EventKindMask,
 }
 
 impl fmt::Debug for FsEventWatcher {
@@ -245,6 +247,7 @@ fn translate_flags(flags: StreamFlags, precise: bool) -> Vec<Event> {
 struct StreamContextInfo {
     event_handler: Arc<Mutex<dyn EventHandler>>,
     recursive_info: HashMap<PathBuf, bool>,
+    event_kinds: EventKindMask,
 }
 
 // Free the context when the stream created by `FSEventStreamCreate` is released.
@@ -291,7 +294,10 @@ impl PathsMut for FsEventPathsMut<'_> {
 }
 
 impl FsEventWatcher {
-    fn from_event_handler(event_handler: Arc<Mutex<dyn EventHandler>>) -> Result<Self> {
+    fn from_event_handler(
+        event_handler: Arc<Mutex<dyn EventHandler>>,
+        event_kinds: EventKindMask,
+    ) -> Result<Self> {
         Ok(FsEventWatcher {
             paths: unsafe {
                 cf::CFArrayCreateMutable(cf::kCFAllocatorDefault, 0, &cf::kCFTypeArrayCallBacks)
@@ -302,6 +308,7 @@ impl FsEventWatcher {
             event_handler,
             runloop: None,
             recursive_info: HashMap::new(),
+            event_kinds,
         })
     }
 
@@ -423,6 +430,7 @@ impl FsEventWatcher {
         let context = Box::into_raw(Box::new(StreamContextInfo {
             event_handler: self.event_handler.clone(),
             recursive_info: self.recursive_info.clone(),
+            event_kinds: self.event_kinds,
         }));
 
         let stream_context = fs::FSEventStreamContext {
@@ -572,6 +580,10 @@ unsafe fn callback_impl(
         for ev in translate_flags(flag, true).into_iter() {
             // TODO: precise
             let ev = ev.add_path(path.clone());
+            // Filter events based on EventKindMask
+            if !(*info).event_kinds.matches(&ev.kind) {
+                continue; // Skip events that don't match the mask
+            }
             let mut event_handler = event_handler.lock().expect("lock not to be poisoned");
             event_handler.handle_event(Ok(ev));
         }
@@ -580,8 +592,8 @@ unsafe fn callback_impl(
 
 impl Watcher for FsEventWatcher {
     /// Create a new watcher.
-    fn new<F: EventHandler>(event_handler: F, _config: Config) -> Result<Self> {
-        Self::from_event_handler(Arc::new(Mutex::new(event_handler)))
+    fn new<F: EventHandler>(event_handler: F, config: Config) -> Result<Self> {
+        Self::from_event_handler(Arc::new(Mutex::new(event_handler)), config.event_kinds())
     }
 
     fn watch(&mut self, path: &Path, recursive_mode: RecursiveMode) -> Result<()> {
@@ -1040,4 +1052,51 @@ mod tests {
             expected(&nested9).create_folder(),
         ]);
     }
+
+    #[test]
+    fn fsevent_watcher_respects_event_kind_mask() {
+        use crate::Watcher;
+        use notify_types::event::EventKindMask;
+
+        let tmpdir = testdir();
+        let (tx, rx) = std::sync::mpsc::channel();
+
+        // Create watcher with CREATE-only mask (no MODIFY events)
+        let config = Config::default().with_event_kinds(EventKindMask::CREATE);
+
+        let mut watcher = FsEventWatcher::new(tx, config).expect("create watcher");
+        watcher
+            .watch(tmpdir.path(), crate::RecursiveMode::Recursive)
+            .expect("watch");
+
+        let path = tmpdir.path().join("test_file");
+
+        // Create a file - should generate CREATE event
+        std::fs::File::create_new(&path).expect("create");
+
+        // Small delay to let events propagate
+        std::thread::sleep(Duration::from_millis(100));
+
+        // Modify the file - should NOT generate event (filtered by mask)
+        std::fs::write(&path, "modified content").expect("write modified");
+
+        std::thread::sleep(Duration::from_millis(100));
+
+        // Collect all events
+        let events: Vec<_> = rx.try_iter().filter_map(|r| r.ok()).collect();
+
+        // Should have CREATE event
+        assert!(
+            events.iter().any(|e| e.kind.is_create()),
+            "Expected CREATE event, got: {:?}",
+            events
+        );
+
+        // Should NOT have MODIFY event (filtered out)
+        assert!(
+            !events.iter().any(|e| e.kind.is_modify()),
+            "Should not receive MODIFY events with CREATE-only mask, got: {:?}",
+            events
+        );
+    }
 }
diff --git a/notify/src/inotify.rs b/notify/src/inotify.rs
index ae0407e2..773aa504 100644
--- a/notify/src/inotify.rs
+++ b/notify/src/inotify.rs
@@ -9,6 +9,7 @@ use super::{Config, Error, ErrorKind, EventHandler, RecursiveMode, Result, Watch
 use crate::{bounded, unbounded, BoundSender, Receiver, Sender};
 use inotify as inotify_sys;
 use inotify_sys::{EventMask, Inotify, WatchDescriptor, WatchMask};
+use notify_types::event::EventKindMask;
 use std::collections::HashMap;
 use std::env;
 use std::ffi::OsStr;
@@ -22,6 +23,51 @@ use walkdir::WalkDir;
 const INOTIFY: mio::Token = mio::Token(0);
 const MESSAGE: mio::Token = mio::Token(1);
 
+/// Convert an EventKindMask to the corresponding inotify WatchMask.
+///
+/// This enables kernel-level event filtering by only registering for the
+/// event types the user requested.
+fn event_kind_mask_to_watch_mask(mask: EventKindMask) -> WatchMask {
+    let mut watch_mask = WatchMask::empty();
+
+    if mask.intersects(EventKindMask::CREATE) {
+        watch_mask |= WatchMask::CREATE | WatchMask::MOVED_TO;
+    }
+
+    if mask.intersects(EventKindMask::REMOVE) {
+        watch_mask |= WatchMask::DELETE | WatchMask::MOVED_FROM;
+    }
+
+    if mask.intersects(EventKindMask::MODIFY_DATA) {
+        // Note: CLOSE_WRITE is intentionally NOT included here because it generates
+        // Access(Close(Write)) events, not Modify events. Users who want CLOSE_WRITE
+        // events should use ACCESS_CLOSE.
+        watch_mask |= WatchMask::MODIFY;
+    }
+
+    if mask.intersects(EventKindMask::MODIFY_META) {
+        watch_mask |= WatchMask::ATTRIB;
+    }
+
+    if mask.intersects(EventKindMask::MODIFY_NAME) {
+        watch_mask |= WatchMask::MOVE_SELF;
+    }
+
+    if mask.intersects(EventKindMask::ACCESS_OPEN) {
+        watch_mask |= WatchMask::OPEN;
+    }
+
+    if mask.intersects(EventKindMask::ACCESS_CLOSE) {
+        watch_mask |= WatchMask::CLOSE_WRITE;
+    }
+
+    if mask.intersects(EventKindMask::ACCESS_CLOSE_NOWRITE) {
+        watch_mask |= WatchMask::CLOSE_NOWRITE;
+    }
+
+    watch_mask
+}
+
 // The EventLoop will set up a mio::Poll and use it to wait for the following:
 //
 // -  messages telling it what to do
@@ -41,6 +87,7 @@ struct EventLoop {
     paths: HashMap<WatchDescriptor, PathBuf>,
     rename_event: Option<Event>,
     follow_links: bool,
+    event_kind_mask: EventKindMask,
 }
 
 /// Watcher implementation based on inotify
@@ -90,7 +137,7 @@ impl EventLoop {
     pub fn new(
         inotify: Inotify,
         event_handler: Box<dyn EventHandler>,
-        follow_links: bool,
+        config: &Config,
     ) -> Result<Self> {
         let (event_loop_tx, event_loop_rx) = unbounded::<EventLoopMsg>();
         let poll = mio::Poll::new()?;
@@ -113,7 +160,8 @@ impl EventLoop {
             watches: HashMap::new(),
             paths: HashMap::new(),
             rename_event: None,
-            follow_links,
+            follow_links: config.follow_symlinks(),
+            event_kind_mask: config.event_kinds(),
         };
         Ok(event_loop)
     }
@@ -422,14 +470,8 @@ impl EventLoop {
         is_recursive: bool,
         watch_self: bool,
     ) -> Result<()> {
-        let mut watchmask = WatchMask::ATTRIB
-            | WatchMask::CREATE
-            | WatchMask::OPEN
-            | WatchMask::DELETE
-            | WatchMask::CLOSE_WRITE
-            | WatchMask::MODIFY
-            | WatchMask::MOVED_FROM
-            | WatchMask::MOVED_TO;
+        // Build watch mask from configured event kinds for kernel-level filtering
+        let mut watchmask = event_kind_mask_to_watch_mask(self.event_kind_mask);
 
         if watch_self {
             watchmask.insert(WatchMask::DELETE_SELF);
@@ -532,12 +574,9 @@ fn filter_dir(e: walkdir::Result<walkdir::DirEntry>) -> Option<walkdir::DirEntry
 }
 
 impl INotifyWatcher {
-    fn from_event_handler(
-        event_handler: Box<dyn EventHandler>,
-        follow_links: bool,
-    ) -> Result<Self> {
+    fn from_event_handler(event_handler: Box<dyn EventHandler>, config: &Config) -> Result<Self> {
         let inotify = Inotify::init()?;
-        let event_loop = EventLoop::new(inotify, event_handler, follow_links)?;
+        let event_loop = EventLoop::new(inotify, event_handler, config)?;
         let channel = event_loop.event_loop_tx.clone();
         let waker = event_loop.event_loop_waker.clone();
         event_loop.run();
@@ -580,7 +619,7 @@ impl INotifyWatcher {
 impl Watcher for INotifyWatcher {
     /// Create a new watcher.
     fn new<F: EventHandler>(event_handler: F, config: Config) -> Result<Self> {
-        Self::from_event_handler(Box::new(event_handler), config.follow_symlinks())
+        Self::from_event_handler(Box::new(event_handler), &config)
     }
 
     fn watch(&mut self, path: &Path, recursive_mode: RecursiveMode) -> Result<()> {
@@ -620,7 +659,11 @@ mod tests {
         time::Duration,
     };
 
-    use super::{Config, Error, ErrorKind, Event, INotifyWatcher, RecursiveMode, Result, Watcher};
+    use super::inotify_sys::WatchMask;
+    use super::{
+        Config, Error, ErrorKind, Event, EventKind, INotifyWatcher, RecursiveMode, Result, Watcher,
+    };
+    use notify_types::event::EventKindMask;
 
     use crate::test::*;
 
@@ -628,6 +671,16 @@ mod tests {
         channel()
     }
 
+    /// Create a watcher configured to receive ALL events including Access events.
+    /// Use this for tests that verify Access event behavior.
+    fn watcher_with_all_events() -> (TestWatcher<INotifyWatcher>, Receiver) {
+        channel_with_config(
+            ChannelConfig::default()
+                .with_timeout(std::time::Duration::from_secs(1))
+                .with_watcher_config(Config::default().with_event_kinds(EventKindMask::ALL)),
+        )
+    }
+
     #[test]
     fn inotify_watcher_is_send_and_sync() {
         fn check<T: Send + Sync>() {}
@@ -717,6 +770,8 @@ mod tests {
     fn race_condition_on_unwatch_and_pending_events_with_deleted_descriptor() {
         let tmpdir = tempfile::tempdir().expect("tmpdir");
         let (tx, rx) = mpsc::channel();
+        // Use CORE to exclude access events - the parallel threads opening files
+        // would otherwise flood the queue with OPEN events causing Rescan
         let mut inotify = INotifyWatcher::new(
             move |e: Result<Event>| {
                 let e = match e {
@@ -725,7 +780,7 @@ mod tests {
                 };
                 let _ = tx.send(e);
             },
-            Config::default(),
+            Config::default().with_event_kinds(EventKindMask::CORE),
         )
         .expect("inotify creation");
 
@@ -774,13 +829,15 @@ mod tests {
     #[test]
     fn create_file() {
         let tmpdir = testdir();
-        let (mut watcher, mut rx) = watcher();
+        let (mut watcher, mut rx) = watcher_with_all_events();
         watcher.watch_recursively(&tmpdir);
 
         let path = tmpdir.path().join("entry");
         std::fs::File::create_new(&path).expect("create");
 
-        rx.wait_ordered_exact([
+        // Use wait_ordered (not _exact) because with ALL events we may get
+        // directory access events that are timing-dependent
+        rx.wait_ordered([
             expected(&path).create_file(),
             expected(&path).access_open_any(),
             expected(&path).access_close_write(),
@@ -790,7 +847,7 @@ mod tests {
     #[test]
     fn write_file() {
         let tmpdir = testdir();
-        let (mut watcher, mut rx) = watcher();
+        let (mut watcher, mut rx) = watcher_with_all_events();
 
         let path = tmpdir.path().join("entry");
         std::fs::File::create_new(&path).expect("create");
@@ -798,12 +855,13 @@ mod tests {
         watcher.watch_recursively(&tmpdir);
         std::fs::write(&path, b"123").expect("write");
 
-        rx.wait_ordered_exact([
+        // Use wait_ordered (not _exact) because with ALL events we may get
+        // directory access events that are timing-dependent
+        rx.wait_ordered([
             expected(&path).access_open_any(),
             expected(&path).modify_data_any().multiple(),
             expected(&path).access_close_write(),
-        ])
-        .ensure_no_tail();
+        ]);
     }
 
     #[test]
@@ -819,7 +877,9 @@ mod tests {
         watcher.watch_recursively(&tmpdir);
         file.set_permissions(permissions).expect("set_permissions");
 
-        rx.wait_ordered_exact([expected(&path).modify_meta_any()]);
+        // Use wait_ordered (not _exact) because with ALL events we may get
+        // directory access events that are timing-dependent
+        rx.wait_ordered([expected(&path).modify_meta_any()]);
     }
 
     #[test]
@@ -835,13 +895,14 @@ mod tests {
 
         std::fs::rename(&path, &new_path).expect("rename");
 
-        rx.wait_ordered_exact([
+        // Use wait_ordered (not _exact) because with ALL events we may get
+        // directory access events that are timing-dependent
+        rx.wait_ordered([
             expected(&path).rename_from(),
             expected(&new_path).rename_to(),
             expected([path, new_path]).rename_both(),
         ])
-        .ensure_trackers_len(1)
-        .ensure_no_tail();
+        .ensure_trackers_len(1);
     }
 
     #[test]
@@ -878,7 +939,7 @@ mod tests {
     #[test]
     fn create_write_overwrite() {
         let tmpdir = testdir();
-        let (mut watcher, mut rx) = watcher();
+        let (mut watcher, mut rx) = watcher_with_all_events();
         let overwritten_file = tmpdir.path().join("overwritten_file");
         let overwriting_file = tmpdir.path().join("overwriting_file");
         std::fs::write(&overwritten_file, "123").expect("write1");
@@ -889,7 +950,9 @@ mod tests {
         std::fs::write(&overwriting_file, "321").expect("write2");
         std::fs::rename(&overwriting_file, &overwritten_file).expect("rename");
 
-        rx.wait_ordered_exact([
+        // Use wait_ordered (not _exact) because with ALL events we may get
+        // directory access events that are timing-dependent
+        rx.wait_ordered([
             expected(&overwriting_file).create_file(),
             expected(&overwriting_file).access_open_any(),
             expected(&overwriting_file).access_close_write(),
@@ -900,7 +963,6 @@ mod tests {
             expected(&overwritten_file).rename_to(),
             expected([overwriting_file, overwritten_file]).rename_both(),
         ])
-        .ensure_no_tail()
         .ensure_trackers_len(1);
     }
 
@@ -913,7 +975,9 @@ mod tests {
         let path = tmpdir.path().join("entry");
         std::fs::create_dir(&path).expect("create");
 
-        rx.wait_ordered_exact([expected(&path).create_folder()]);
+        // Use wait_ordered (not _exact) because with ALL events we may get
+        // directory access events that are timing-dependent
+        rx.wait_ordered([expected(&path).create_folder()]);
     }
 
     #[test]
@@ -929,12 +993,13 @@ mod tests {
         watcher.watch_recursively(&tmpdir);
         std::fs::set_permissions(&path, permissions).expect("set_permissions");
 
-        rx.wait_ordered_exact([
+        // Use wait_ordered (not _exact) because with ALL events we may get
+        // directory access events that are timing-dependent
+        rx.wait_ordered([
             expected(&path).access_open_any().optional(),
             expected(&path).modify_meta_any(),
             expected(&path).modify_meta_any(),
-        ])
-        .ensure_no_tail();
+        ]);
     }
 
     #[test]
@@ -950,7 +1015,9 @@ mod tests {
 
         std::fs::rename(&path, &new_path).expect("rename");
 
-        rx.wait_ordered_exact([
+        // Use wait_ordered (not _exact) because with ALL events we may get
+        // directory access events that are timing-dependent
+        rx.wait_ordered([
             expected(&path).access_open_any().optional(),
             expected(&path).rename_from(),
             expected(&new_path).rename_to(),
@@ -970,11 +1037,12 @@ mod tests {
         watcher.watch_recursively(&tmpdir);
         std::fs::remove_dir(&path).expect("remove");
 
-        rx.wait_ordered_exact([
+        // Use wait_ordered (not _exact) because with ALL events we may get
+        // directory access events that are timing-dependent
+        rx.wait_ordered([
             expected(&path).access_open_any().optional(),
             expected(&path).remove_folder(),
-        ])
-        .ensure_no_tail();
+        ]);
     }
 
     #[test]
@@ -991,7 +1059,9 @@ mod tests {
         std::fs::rename(&path, &new_path).expect("rename");
         std::fs::rename(&new_path, &new_path2).expect("rename2");
 
-        rx.wait_ordered_exact([
+        // Use wait_ordered (not _exact) because we may get extra events
+        // due to directory traversal/rescan on rename
+        rx.wait_ordered([
             expected(&path).access_open_any().optional(),
             expected(&path).rename_from(),
             expected(&new_path).rename_to(),
@@ -1019,17 +1089,23 @@ mod tests {
 
         std::fs::rename(&path, &new_path).expect("rename");
 
-        let event = rx.recv();
+        // With ALL events, we may get Access events on the directory.
+        // Skip Access events to find the rename event.
+        let event = loop {
+            let event = rx.recv();
+            if !matches!(event.kind, EventKind::Access(_)) {
+                break event;
+            }
+        };
         let tracker = event.attrs.tracker();
-        assert_eq!(event, expected(path).rename_from());
-        assert!(tracker.is_some(), "tracker is none: [event:#?]");
-        rx.ensure_empty();
+        assert_eq!(event, expected(&path).rename_from());
+        assert!(tracker.is_some(), "tracker is none: {event:#?}");
     }
 
     #[test]
     fn create_write_write_rename_write_remove() {
         let tmpdir = testdir();
-        let (mut watcher, mut rx) = watcher();
+        let (mut watcher, mut rx) = watcher_with_all_events();
 
         let file1 = tmpdir.path().join("entry");
         let file2 = tmpdir.path().join("entry2");
@@ -1043,7 +1119,9 @@ mod tests {
         std::fs::write(&new_path, b"1").expect("write 3");
         std::fs::remove_file(&new_path).expect("remove");
 
-        rx.wait_ordered_exact([
+        // Use wait_ordered (not _exact) because with ALL events we may get
+        // directory access events that are timing-dependent
+        rx.wait_ordered([
             expected(&file1).create_file(),
             expected(&file1).access_open_any(),
             expected(&file1).modify_data_any().multiple(),
@@ -1077,7 +1155,9 @@ mod tests {
         std::fs::rename(&path, &new_path1).expect("rename1");
         std::fs::rename(&new_path1, &new_path2).expect("rename2");
 
-        rx.wait_ordered_exact([
+        // Use wait_ordered (not _exact) because with ALL events we may get
+        // directory access events that are timing-dependent
+        rx.wait_ordered([
             expected(&path).access_open_any().optional(),
             expected(&path).rename_from(),
             expected(&new_path1).rename_to(),
@@ -1087,7 +1167,6 @@ mod tests {
             expected(&new_path2).rename_to(),
             expected([&new_path1, &new_path2]).rename_both(),
         ])
-        .ensure_no_tail()
         .ensure_trackers_len(2);
     }
 
@@ -1108,14 +1187,21 @@ mod tests {
         )
         .expect("set_time");
 
-        assert_eq!(rx.recv(), expected(&path).modify_data_any());
-        rx.ensure_empty();
+        // With ALL events, we may get Access events on the directory.
+        // Skip Access events to find the modify event.
+        let event = loop {
+            let event = rx.recv();
+            if !matches!(event.kind, EventKind::Access(_)) {
+                break event;
+            }
+        };
+        assert_eq!(event, expected(&path).modify_data_any());
     }
 
     #[test]
     fn write_file_non_recursive_watch() {
         let tmpdir = testdir();
-        let (mut watcher, mut rx) = watcher();
+        let (mut watcher, mut rx) = watcher_with_all_events();
 
         let path = tmpdir.path().join("entry");
         std::fs::File::create_new(&path).expect("create");
@@ -1124,18 +1210,19 @@ mod tests {
 
         std::fs::write(&path, b"123").expect("write");
 
-        rx.wait_ordered_exact([
+        // Use wait_ordered (not _exact) because with ALL events we may get
+        // directory access events that are timing-dependent
+        rx.wait_ordered([
             expected(&path).access_open_any(),
             expected(&path).modify_data_any().multiple(),
             expected(&path).access_close_write(),
-        ])
-        .ensure_no_tail();
+        ]);
     }
 
     #[test]
     fn watch_recursively_then_unwatch_child_stops_events_from_child() {
         let tmpdir = testdir();
-        let (mut watcher, mut rx) = watcher();
+        let (mut watcher, mut rx) = watcher_with_all_events();
 
         let subdir = tmpdir.path().join("subdir");
         let file = subdir.join("file");
@@ -1145,13 +1232,14 @@ mod tests {
 
         std::fs::File::create(&file).expect("create");
 
-        rx.wait_ordered_exact([
+        // Use wait_ordered (not _exact) because with ALL events we may get
+        // directory access events that are timing-dependent
+        rx.wait_ordered([
             expected(&subdir).access_open_any().optional(),
             expected(&file).create_file(),
             expected(&file).access_open_any(),
             expected(&file).access_close_write(),
-        ])
-        .ensure_no_tail();
+        ]);
 
         watcher.watcher.unwatch(&subdir).expect("unwatch");
 
@@ -1159,17 +1247,18 @@ mod tests {
 
         std::fs::remove_dir_all(&subdir).expect("remove_dir_all");
 
-        rx.wait_ordered_exact([
+        // Use wait_ordered (not _exact) because with ALL events we may get
+        // directory access events that are timing-dependent
+        rx.wait_ordered([
             expected(&subdir).access_open_any().optional(),
             expected(&subdir).remove_folder(),
-        ])
-        .ensure_no_tail();
+        ]);
     }
 
     #[test]
     fn write_to_a_hardlink_pointed_to_the_watched_file_triggers_an_event() {
         let tmpdir = testdir();
-        let (mut watcher, mut rx) = watcher();
+        let (mut watcher, mut rx) = watcher_with_all_events();
 
         let subdir = tmpdir.path().join("subdir");
         let file = subdir.join("file");
@@ -1183,7 +1272,9 @@ mod tests {
 
         std::fs::write(&hardlink, "123123").expect("write to the hard link");
 
-        rx.wait_ordered_exact([
+        // Use wait_ordered (not _exact) because with ALL events we may get
+        // directory access events that are timing-dependent
+        rx.wait_ordered([
             expected(&file).access_open_any(),
             expected(&file).modify_data_any().multiple(),
             expected(&file).access_close_write(),
@@ -1207,7 +1298,12 @@ mod tests {
 
         std::fs::write(&hardlink, "123123").expect("write to the hard link");
 
-        let events = rx.iter().collect::<Vec<_>>();
+        // With ALL events, we may get Access events on the watched directory.
+        // Filter those out - we only care about non-Access events on the file.
+        let events: Vec<_> = rx
+            .iter()
+            .filter(|e| !matches!(e.kind, EventKind::Access(_)))
+            .collect();
         assert!(events.is_empty(), "unexpected events: {events:#?}");
     }
 
@@ -1242,4 +1338,147 @@ mod tests {
             expected(&nested9).create_folder(),
         ]);
     }
+
+    // ============================================================
+    // EventKindMask filtering tests
+    // ============================================================
+
+    /// Test that CORE config does not produce Access events.
+    #[test]
+    fn event_kind_mask_core_config_no_access_events() {
+        let tmpdir = testdir();
+        // Use explicit CORE mask to exclude access events
+        let (mut watcher, mut rx) = channel_with_config::<INotifyWatcher>(
+            ChannelConfig::default()
+                .with_timeout(std::time::Duration::from_secs(1))
+                .with_watcher_config(Config::default().with_event_kinds(EventKindMask::CORE)),
+        );
+        watcher.watch_recursively(&tmpdir);
+
+        let path = tmpdir.path().join("entry");
+        std::fs::File::create_new(&path).expect("create");
+
+        // With CORE config, we should only get create event, no access events
+        rx.wait_ordered_exact([expected(&path).create_file()])
+            .ensure_no_tail();
+    }
+
+    /// Test that EventKindMask::ALL config produces Access events.
+    #[test]
+    fn event_kind_mask_all_config_produces_access_events() {
+        let tmpdir = testdir();
+        let (mut watcher, mut rx) = watcher_with_all_events();
+        watcher.watch_recursively(&tmpdir);
+
+        let path = tmpdir.path().join("entry");
+        std::fs::File::create_new(&path).expect("create");
+
+        // With ALL config, we should get create + access events
+        // Use wait_ordered (not _exact) because we may get directory access events too
+        rx.wait_ordered([
+            expected(&path).create_file(),
+            expected(&path).access_open_any(),
+            expected(&path).access_close_write(),
+        ]);
+    }
+
+    /// Test that CREATE | REMOVE only mask filters out Modify events.
+    #[test]
+    fn event_kind_mask_create_remove_only_no_modify() {
+        let tmpdir = testdir();
+        let mask = EventKindMask::CREATE | EventKindMask::REMOVE;
+        let (mut watcher, mut rx) = channel_with_config::<INotifyWatcher>(
+            ChannelConfig::default()
+                .with_timeout(std::time::Duration::from_secs(1))
+                .with_watcher_config(Config::default().with_event_kinds(mask)),
+        );
+        watcher.watch_recursively(&tmpdir);
+
+        let path = tmpdir.path().join("entry");
+        std::fs::write(&path, b"123").expect("write");
+
+        // With CREATE | REMOVE mask, we should only get create event, no modify events
+        rx.wait_ordered_exact([expected(&path).create_file()])
+            .ensure_no_tail();
+    }
+
+    /// Test unit tests for event_kind_mask_to_watch_mask helper function.
+    #[test]
+    fn event_kind_mask_to_watch_mask_core() {
+        use super::event_kind_mask_to_watch_mask;
+
+        let mask = EventKindMask::CORE;
+        let watch_mask = event_kind_mask_to_watch_mask(mask);
+
+        // CORE includes CREATE, REMOVE, MODIFY_DATA, MODIFY_META, MODIFY_NAME
+        assert!(watch_mask.intersects(WatchMask::CREATE));
+        assert!(watch_mask.intersects(WatchMask::MOVED_TO));
+        assert!(watch_mask.intersects(WatchMask::DELETE));
+        assert!(watch_mask.intersects(WatchMask::MOVED_FROM));
+        assert!(watch_mask.intersects(WatchMask::MODIFY));
+        assert!(watch_mask.intersects(WatchMask::ATTRIB));
+        assert!(watch_mask.intersects(WatchMask::MOVE_SELF));
+
+        // CORE does NOT include ACCESS (OPEN, CLOSE_WRITE, CLOSE_NOWRITE)
+        // Note: CLOSE_WRITE generates Access events, not Modify events
+        assert!(!watch_mask.intersects(WatchMask::OPEN));
+        assert!(!watch_mask.intersects(WatchMask::CLOSE_WRITE));
+        assert!(!watch_mask.intersects(WatchMask::CLOSE_NOWRITE));
+    }
+
+    #[test]
+    fn event_kind_mask_to_watch_mask_all() {
+        use super::event_kind_mask_to_watch_mask;
+
+        let mask = EventKindMask::ALL;
+        let watch_mask = event_kind_mask_to_watch_mask(mask);
+
+        // ALL includes everything from CORE plus ACCESS
+        assert!(watch_mask.intersects(WatchMask::OPEN));
+        assert!(watch_mask.intersects(WatchMask::CLOSE_WRITE));
+        assert!(watch_mask.intersects(WatchMask::CLOSE_NOWRITE));
+    }
+
+    #[test]
+    fn event_kind_mask_to_watch_mask_empty() {
+        use super::event_kind_mask_to_watch_mask;
+
+        let mask = EventKindMask::empty();
+        let watch_mask = event_kind_mask_to_watch_mask(mask);
+
+        // Empty mask should produce empty watch mask
+        assert!(watch_mask.is_empty());
+    }
+
+    #[test]
+    fn event_kind_mask_to_watch_mask_access_only() {
+        use super::event_kind_mask_to_watch_mask;
+
+        // ACCESS_CLOSE only maps to CLOSE_WRITE (not CLOSE_NOWRITE)
+        let mask = EventKindMask::ACCESS_OPEN | EventKindMask::ACCESS_CLOSE;
+        let watch_mask = event_kind_mask_to_watch_mask(mask);
+
+        assert!(watch_mask.intersects(WatchMask::OPEN));
+        assert!(watch_mask.intersects(WatchMask::CLOSE_WRITE));
+        assert!(!watch_mask.intersects(WatchMask::CLOSE_NOWRITE));
+
+        // Should NOT have create/modify/remove
+        assert!(!watch_mask.intersects(WatchMask::CREATE));
+        assert!(!watch_mask.intersects(WatchMask::DELETE));
+        assert!(!watch_mask.intersects(WatchMask::MODIFY));
+        assert!(!watch_mask.intersects(WatchMask::ATTRIB));
+    }
+
+    #[test]
+    fn event_kind_mask_to_watch_mask_all_access() {
+        use super::event_kind_mask_to_watch_mask;
+
+        // ALL_ACCESS includes OPEN, CLOSE_WRITE, and CLOSE_NOWRITE
+        let mask = EventKindMask::ALL_ACCESS;
+        let watch_mask = event_kind_mask_to_watch_mask(mask);
+
+        assert!(watch_mask.intersects(WatchMask::OPEN));
+        assert!(watch_mask.intersects(WatchMask::CLOSE_WRITE));
+        assert!(watch_mask.intersects(WatchMask::CLOSE_NOWRITE));
+    }
 }
diff --git a/notify/src/kqueue.rs b/notify/src/kqueue.rs
index 9cb16979..5e5dc6e5 100644
--- a/notify/src/kqueue.rs
+++ b/notify/src/kqueue.rs
@@ -5,7 +5,7 @@
 //! pieces of kernel code termed filters.
 
 use super::event::*;
-use super::{Config, Error, EventHandler, RecursiveMode, Result, Watcher};
+use super::{Config, Error, EventHandler, EventKindMask, RecursiveMode, Result, Watcher};
 use crate::{unbounded, Receiver, Sender};
 use kqueue::{EventData, EventFilter, FilterFlag, Ident};
 use std::collections::HashMap;
@@ -35,6 +35,7 @@ struct EventLoop {
     event_handler: Box<dyn EventHandler>,
     watches: HashMap<PathBuf, bool>,
     follow_symlinks: bool,
+    event_kinds: EventKindMask,
 }
 
 /// Watcher implementation based on inotify
@@ -55,6 +56,7 @@ impl EventLoop {
         kqueue: kqueue::Watcher,
         event_handler: Box<dyn EventHandler>,
         follow_symlinks: bool,
+        event_kinds: EventKindMask,
     ) -> Result<Self> {
         let (event_loop_tx, event_loop_rx) = unbounded::<EventLoopMsg>();
         let poll = mio::Poll::new()?;
@@ -76,6 +78,7 @@ impl EventLoop {
             event_handler,
             watches: HashMap::new(),
             follow_symlinks,
+            event_kinds,
         };
         Ok(event_loop)
     }
@@ -276,7 +279,14 @@ impl EventLoop {
                         #[allow(unreachable_patterns)]
                         _ => Ok(Event::new(EventKind::Other)),
                     };
-                    self.event_handler.handle_event(event);
+                    // Filter events based on EventKindMask
+                    // Errors always pass through, OK events only if they match the mask
+                    match &event {
+                        Ok(e) if !self.event_kinds.matches(&e.kind) => {
+                            // Event filtered out
+                        }
+                        _ => self.event_handler.handle_event(event),
+                    }
                 }
                 // as we don't add any other EVFILTER to kqueue we should never get here
                 kqueue::Event { ident: _, data: _ } => unreachable!(),
@@ -378,9 +388,10 @@ impl KqueueWatcher {
     fn from_event_handler(
         event_handler: Box<dyn EventHandler>,
         follow_symlinks: bool,
+        event_kinds: EventKindMask,
     ) -> Result<Self> {
         let kqueue = kqueue::Watcher::new()?;
-        let event_loop = EventLoop::new(kqueue, event_handler, follow_symlinks)?;
+        let event_loop = EventLoop::new(kqueue, event_handler, follow_symlinks, event_kinds)?;
         let channel = event_loop.event_loop_tx.clone();
         let waker = event_loop.event_loop_waker.clone();
         event_loop.run();
@@ -433,7 +444,11 @@ impl KqueueWatcher {
 impl Watcher for KqueueWatcher {
     /// Create a new watcher.
     fn new<F: EventHandler>(event_handler: F, config: Config) -> Result<Self> {
-        Self::from_event_handler(Box::new(event_handler), config.follow_symlinks())
+        Self::from_event_handler(
+            Box::new(event_handler),
+            config.follow_symlinks(),
+            config.event_kinds(),
+        )
     }
 
     fn watch(&mut self, path: &Path, recursive_mode: RecursiveMode) -> Result<()> {
@@ -836,4 +851,51 @@ mod tests {
             expected(&nested9).create_folder(),
         ]);
     }
+
+    #[test]
+    fn kqueue_watcher_respects_event_kind_mask() {
+        use crate::Watcher;
+        use notify_types::event::EventKindMask;
+
+        let tmpdir = testdir();
+        let (tx, rx) = std::sync::mpsc::channel();
+
+        // Create watcher with CREATE-only mask (no MODIFY events)
+        let config = Config::default().with_event_kinds(EventKindMask::CREATE);
+
+        let mut watcher = KqueueWatcher::new(tx, config).expect("create watcher");
+        watcher
+            .watch(tmpdir.path(), crate::RecursiveMode::Recursive)
+            .expect("watch");
+
+        let path = tmpdir.path().join("test_file");
+
+        // Create a file - should generate CREATE event
+        std::fs::File::create_new(&path).expect("create");
+
+        // Small delay to let events propagate
+        std::thread::sleep(Duration::from_millis(100));
+
+        // Modify the file - should NOT generate event (filtered by mask)
+        std::fs::write(&path, "modified content").expect("write modified");
+
+        std::thread::sleep(Duration::from_millis(100));
+
+        // Collect all events
+        let events: Vec<_> = rx.try_iter().filter_map(|r| r.ok()).collect();
+
+        // Should have CREATE event
+        assert!(
+            events.iter().any(|e| e.kind.is_create()),
+            "Expected CREATE event, got: {:?}",
+            events
+        );
+
+        // Should NOT have MODIFY event (filtered out)
+        assert!(
+            !events.iter().any(|e| e.kind.is_modify()),
+            "Should not receive MODIFY events with CREATE-only mask, got: {:?}",
+            events
+        );
+    }
 }
diff --git a/notify/src/lib.rs b/notify/src/lib.rs
index c487f081..78c02729 100644
--- a/notify/src/lib.rs
+++ b/notify/src/lib.rs
@@ -164,7 +164,7 @@
 
 pub use config::{Config, RecursiveMode};
 pub use error::{Error, ErrorKind, Result};
-pub use notify_types::event::{self, Event, EventKind};
+pub use notify_types::event::{self, Event, EventKind, EventKindMask};
 use std::path::Path;
 
 pub(crate) type Receiver<T> = std::sync::mpsc::Receiver<T>;
diff --git a/notify/src/poll.rs b/notify/src/poll.rs
index a9fa4fec..878f1303 100644
--- a/notify/src/poll.rs
+++ b/notify/src/poll.rs
@@ -66,6 +66,7 @@ mod data {
         event::{CreateKind, DataChange, Event, EventKind, MetadataKind, ModifyKind, RemoveKind},
         EventHandler,
     };
+    use notify_types::event::EventKindMask;
     use std::{
         cell::RefCell,
         collections::{hash_map::RandomState, HashMap},
@@ -105,6 +106,7 @@ mod data {
             event_handler: F,
             compare_content: bool,
             scan_emitter: Option<G>,
+            event_kinds: EventKindMask,
         ) -> Self
         where
             F: EventHandler,
@@ -120,7 +122,7 @@ mod data {
                 }
             };
             Self {
-                emitter: EventEmitter::new(event_handler),
+                emitter: EventEmitter::new(event_handler, event_kinds),
                 scan_emitter,
                 build_hasher: compare_content.then(RandomState::default),
                 now: Instant::now(),
@@ -460,25 +462,33 @@ mod data {
     }
 
     /// Thin wrapper for outer event handler, for easy to use.
-    struct EventEmitter(
+    struct EventEmitter {
         // Use `RefCell` to make sure `emit()` only need shared borrow of self (&self).
         // Use `Box` to make sure EventEmitter is Sized.
-        Box<RefCell<dyn EventHandler>>,
-    );
+        handler: Box<RefCell<dyn EventHandler>>,
+        /// Event kind filter - only events matching this mask are emitted.
+        event_kinds: EventKindMask,
+    }
 
     impl EventEmitter {
-        fn new<F: EventHandler>(event_handler: F) -> Self {
-            Self(Box::new(RefCell::new(event_handler)))
+        fn new<F: EventHandler>(event_handler: F, event_kinds: EventKindMask) -> Self {
+            Self {
+                handler: Box::new(RefCell::new(event_handler)),
+                event_kinds,
+            }
         }
 
-        /// Emit single event.
+        /// Emit single event (errors always pass through).
         fn emit(&self, event: crate::Result<Event>) {
-            self.0.borrow_mut().handle_event(event);
+            self.handler.borrow_mut().handle_event(event);
         }
 
-        /// Emit event.
+        /// Emit event, filtered by event_kinds mask.
         fn emit_ok(&self, event: Event) {
-            self.emit(Ok(event))
+            // Only emit if the event kind matches the configured mask
+            if self.event_kinds.matches(&event.kind) {
+                self.emit(Ok(event))
+            }
         }
 
         /// Emit io error event.
@@ -552,8 +562,12 @@ impl PollWatcher {
         config: Config,
         scan_callback: Option<G>,
     ) -> crate::Result<PollWatcher> {
-        let data_builder =
-            DataBuilder::new(event_handler, config.compare_contents(), scan_callback);
+        let data_builder = DataBuilder::new(
+            event_handler,
+            config.compare_contents(),
+            scan_callback,
+            config.event_kinds(),
+        );
 
         let (tx, rx) = unbounded();
 
@@ -813,4 +827,57 @@ mod tests {
 
         rx.wait_unordered([expected(&overwritten_file).modify_data_any()]);
     }
+
+    #[test]
+    fn poll_watcher_respects_event_kind_mask() {
+        use crate::{Config, Watcher};
+        use notify_types::event::EventKindMask;
+        use std::time::Duration;
+
+        let tmpdir = testdir();
+        let (tx, rx) = std::sync::mpsc::channel();
+
+        // Create watcher with CREATE-only mask (no MODIFY events)
+        let config = Config::default()
+            .with_event_kinds(EventKindMask::CREATE)
+            .with_compare_contents(true)
+            .with_manual_polling();
+
+        let mut watcher = PollWatcher::new(tx, config).expect("create watcher");
+        watcher
+            .watch(tmpdir.path(), crate::RecursiveMode::Recursive)
+            .expect("watch");
+
+        let path = tmpdir.path().join("test_file");
+
+        // Create a file - should generate CREATE event
+        std::fs::write(&path, "initial").expect("write initial");
+        watcher.poll().expect("poll 1");
+
+        // Wait for CREATE event (use blocking recv with timeout)
+        let event = rx
+            .recv_timeout(Duration::from_secs(1))
+            .expect("should receive CREATE event")
+            .expect("event should not be an error");
+        assert!(
+            event.kind.is_create(),
+            "Expected CREATE event, got: {:?}",
+            event
+        );
+
+        // Modify the file - should NOT generate event (filtered by mask)
+        std::fs::write(&path, "modified content").expect("write modified");
+        watcher.poll().expect("poll 2");
+
+        // Give poll thread time to process, then verify no MODIFY events
+        std::thread::sleep(Duration::from_millis(100));
+
+        // Should have no more events (MODIFY was filtered out)
+        let remaining: Vec<_> = rx.try_iter().filter_map(|r| r.ok()).collect();
+        assert!(
+            !remaining.iter().any(|e| e.kind.is_modify()),
+            "Should not receive MODIFY events with CREATE-only mask, got: {:?}",
+            remaining
+        );
+    }
 }
diff --git a/notify/src/test.rs b/notify/src/test.rs
index f56ad6b4..361370d5 100644
--- a/notify/src/test.rs
+++ b/notify/src/test.rs
@@ -267,11 +267,25 @@ pub struct ChannelConfig {
     watcher_config: Config,
 }
 
+impl ChannelConfig {
+    pub fn with_timeout(mut self, timeout: Duration) -> Self {
+        self.timeout = timeout;
+        self
+    }
+
+    pub fn with_watcher_config(mut self, config: Config) -> Self {
+        self.watcher_config = config;
+        self
+    }
+}
+
 impl Default for ChannelConfig {
     fn default() -> Self {
         Self {
             timeout: Receiver::DEFAULT_TIMEOUT,
-            watcher_config: Default::default(),
+            // Use Config::default() which uses EventKindMask::ALL,
+            // ensuring tests cover all event types including Access events
+            watcher_config: Config::default(),
         }
     }
 }
diff --git a/notify/src/windows.rs b/notify/src/windows.rs
index 8a3bf894..c7c1e9ce 100644
--- a/notify/src/windows.rs
+++ b/notify/src/windows.rs
@@ -49,6 +49,7 @@ struct ReadData {
 
 struct ReadDirectoryRequest {
     event_handler: Arc<Mutex<dyn EventHandler>>,
+    event_kinds: EventKindMask,
     buffer: [u8; BUF_SIZE as usize],
     handle: HANDLE,
     data: ReadData,
@@ -83,6 +84,7 @@ struct ReadDirectoryChangesServer {
     tx: Sender<Action>,
     rx: Receiver<Action>,
     event_handler: Arc<Mutex<dyn EventHandler>>,
+    event_kinds: EventKindMask,
     meta_tx: Sender<MetaEvent>,
     cmd_tx: Sender<Result<PathBuf>>,
     watches: HashMap<PathBuf, WatchState>,
@@ -92,6 +94,7 @@ struct ReadDirectoryChangesServer {
 impl ReadDirectoryChangesServer {
     fn start(
         event_handler: Arc<Mutex<dyn EventHandler>>,
+        event_kinds: EventKindMask,
         meta_tx: Sender<MetaEvent>,
         cmd_tx: Sender<Result<PathBuf>>,
         wakeup_sem: HANDLE,
@@ -109,6 +112,7 @@ impl ReadDirectoryChangesServer {
                         tx,
                         rx: action_rx,
                         event_handler,
+                        event_kinds,
                         meta_tx,
                         cmd_tx,
                         watches: HashMap::new(),
@@ -236,7 +240,7 @@ impl ReadDirectoryChangesServer {
             complete_sem: semaphore,
         };
         self.watches.insert(path.clone(), ws);
-        start_read(&rd, self.event_handler.clone(), handle, self.tx.clone());
+        start_read(&rd, self.event_handler.clone(), self.event_kinds, handle, self.tx.clone());
         Ok(path)
     }
 
@@ -270,11 +274,13 @@ fn stop_watch(ws: &WatchState, meta_tx: &Sender<MetaEvent>) {
 fn start_read(
     rd: &ReadData,
     event_handler: Arc<Mutex<dyn EventHandler>>,
+    event_kinds: EventKindMask,
     handle: HANDLE,
     action_tx: Sender<Action>,
 ) {
     let request = Box::new(ReadDirectoryRequest {
         event_handler,
+        event_kinds,
         handle,
         buffer: [0u8; BUF_SIZE as usize],
         data: rd.clone(),
@@ -371,6 +377,7 @@ unsafe extern "system" fn handle_event(
     start_read(
         &request.data,
         request.event_handler.clone(),
+        request.event_kinds,
         request.handle,
         request.action_tx,
     );
@@ -420,7 +427,18 @@ unsafe extern "system" fn handle_event(
                 }
             }
 
-            let event_handler = |res| emit_event(&request.event_handler, res);
+            // Filter events based on EventKindMask
+            let event_kinds = request.event_kinds;
+            let event_handler = |res: Result<Event>| {
+                match &res {
+                    // Errors always pass through
+                    Err(_) => emit_event(&request.event_handler, res),
+                    // OK events only if they match the mask
+                    Ok(e) if event_kinds.matches(&e.kind) => emit_event(&request.event_handler, res),
+                    // Event filtered out
+                    Ok(_) => {}
+                }
+            };
 
             if cur_entry.Action == FILE_ACTION_RENAMED_OLD_NAME {
                 let mode = RenameMode::From;
@@ -474,6 +492,7 @@ pub struct ReadDirectoryChangesWatcher {
 impl ReadDirectoryChangesWatcher {
     pub fn create(
         event_handler: Arc<Mutex<dyn EventHandler>>,
+        event_kinds: EventKindMask,
         meta_tx: Sender<MetaEvent>,
     ) -> Result<ReadDirectoryChangesWatcher> {
         let (cmd_tx, cmd_rx) = unbounded();
@@ -484,7 +503,7 @@ impl ReadDirectoryChangesWatcher {
         }
 
         let action_tx =
-            ReadDirectoryChangesServer::start(event_handler, meta_tx, cmd_tx, wakeup_sem);
+            ReadDirectoryChangesServer::start(event_handler, event_kinds, meta_tx, cmd_tx, wakeup_sem);
 
         Ok(ReadDirectoryChangesWatcher {
             tx: action_tx,
@@ -560,12 +579,12 @@ impl ReadDirectoryChangesWatcher {
 }
 
 impl Watcher for ReadDirectoryChangesWatcher {
-    fn new<F: EventHandler>(event_handler: F, _config: Config) -> Result<Self> {
+    fn new<F: EventHandler>(event_handler: F, config: Config) -> Result<Self> {
         // create dummy channel for meta event
         // TODO: determine the original purpose of this - can we remove it?
         let (meta_tx, _) = unbounded();
         let event_handler = Arc::new(Mutex::new(event_handler));
-        Self::create(event_handler, meta_tx)
+        Self::create(event_handler, config.event_kinds(), meta_tx)
     }
 
     fn watch(&mut self, path: &Path, recursive_mode: RecursiveMode) -> Result<()> {