Find a Celebrant
The Caledonian Humanists provide a group of celebrants who are highly trained, regulated and insured. Each will work closely with you to create a ceremony that is warm, inclusive and above all, deeply personal to those involved.
Filter Categories
All Celebrants
Central Scotland
South Scotland
Mid Scotland & Fife
Funerals
Highlands & Islands
Naming
Glasgow
Edinburgh & Lothians
Weddings
{"map_options":{"center_lat":"55.856704","center_lng":"-3.768032","zoom":10,"map_type_id":"ROADMAP","center_by_nearest":false,"fit_bounds":true,"center_circle_fillcolor":"#8CAEF2","center_circle_fillopacity":".5","center_circle_strokecolor":"#8CAEF2","center_circle_strokeopacity":".5","center_circle_radius":"5","show_center_circle":false,"show_center_marker":false,"center_marker_icon":"https:\/\/cha.urwinstudio.com\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/\/default_marker.png","center_circle_strokeweight":"1","draggable":true,"gesture":"auto","marker_default_icon":"https:\/\/cha.urwinstudio.com\/wp-content\/uploads\/map-marker-1.png","infowindow_setting":"<div class=\"fc-main\">\n<div class=\"fc-item-title\">{marker_title} <span class=\"fc-badge info\">{marker_category}<\/span><\/div>\n<div class=\"fc-item-featured_image\">{marker_image} <\/div>\n<p>{marker_message}<\/p>\n<address><b>Address : <\/b>{marker_address}<\/address>\n<\/div>\n","infowindow_geotags_setting":"<div class=\"fc-item-box fc-item-no-padding\"> \r\n<div class=\"boxPadded\">\r\n<p><a href=\"{post_link}\">{post_featured_image}<\/a><\/p>\r\n<h3><a href=\"{post_link}\">{post_title}<\/a><\/h3>\r\n<p>{post_excerpt}<\/p>\r\n<a class=\"btn\" href=\"{post_link}\">Celebrant Profile<\/a>\r\n<\/div>\r\n<\/div>","infowindow_skin":{"name":"default","type":"infowindow","sourcecode":"<div class=\"fc-main\"><div class=\"fc-item-title\">{marker_title} <span class=\"fc-badge info\">{marker_category}<\/span><\/div> <div class=\"fc-item-featured_image\">{marker_image} <\/div>{marker_message}<address><b>Address : <\/b>{marker_address}<\/address><\/div>"},"infowindow_post_skin":{"name":"default","type":"post","sourcecode":"<div class=\"fc-item-box fc-item-no-padding\"> \r\n<div class=\"boxPadded\">\r\n<p><a href=\"{post_link}\">{post_featured_image}<\/a><\/p>\r\n<h3><a href=\"{post_link}\">{post_title}<\/a><\/h3>\r\n<p>{post_excerpt}<\/p>\r\n<a class=\"btn\" href=\"{post_link}\">Celebrant Profile<\/a>\r\n<\/div>\r\n<\/div>"},"infowindow_drop_animation":false,"close_infowindow_on_map_click":false,"default_infowindow_open":false,"infowindow_open_event":"click","listing_infowindow_open_event":"click","is_mobile":false,"infowindow_filter_only":false,"infowindow_click_change_zoom":0,"infowindow_click_change_center":false,"full_screen_control":true,"search_control":true,"zoom_control":true,"map_type_control":true,"street_view_control":true,"locateme_control":false,"mobile_specific":false,"zoom_mobile":5,"draggable_mobile":true,"scroll_wheel_mobile":true,"full_screen_control_position":"TOP_RIGHT","search_control_position":"TOP_LEFT","locateme_control_position":"TOP_LEFT","zoom_control_position":"TOP_LEFT","map_type_control_position":"TOP_RIGHT","map_type_control_style":"HORIZONTAL_BAR","street_view_control_position":"TOP_LEFT","map_control":false,"screens":{"smartphones":{"map_zoom_level_mobile":"5"},"ipads":{"map_zoom_level_mobile":"5"},"large-screens":{"map_zoom_level_mobile":"5"}},"map_infowindow_customisations":false,"infowindow_width":"100%","infowindow_border_color":"rgba(0, 0, 0, 0.0980392)","infowindow_bg_color":"#fff","show_infowindow_header":false,"min_zoom":"5","max_zoom":"19","zoom_level_after_search":10,"url_filters":false,"doubleclickzoom":false,"current_post_only":false,"bound_map_after_filter":false,"display_reset_button":false,"map_reset_button_text":"Reset","height":"600"},"places":[{"source":"post","title":"Gillian Monaghan","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\"> \r\n<div class=\"boxPadded\">\r\n<p><a href=\"https:\/\/humanists.scot\/celebrants\/gillian-monaghan\/\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Gillian Monaghan\" width=\"300\" height=\"205\" src=\"https:\/\/humanists.scot\/wp-content\/uploads\/Gillian-Monaghan-Profile-Pic-300x205.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><\/a><\/p>\r\n<h3><a href=\"https:\/\/humanists.scot\/celebrants\/gillian-monaghan\/\">Gillian Monaghan<\/a><\/h3>\r\n<p>Hi, I am Steven Muir and I live in Barrhead, near Paisley, with my wife Kate, between us we have five grown up children and numerous grandchildren!<\/p>\r\n<a class=\"btn\" href=\"https:\/\/humanists.scot\/celebrants\/gillian-monaghan\/\">Celebrant Profile<\/a>\r\n<\/div>\r\n<\/div>","content":"Hi, I am Steven Muir and I live in Barrhead, near Paisley, with my wife Kate, between us we have five grown up children and numerous grandchildren!","address":"Barrhead, UK","location":{"lat":"55.79671099999999","lng":"-4.397714000000001","onclick_action":"marker","redirect_permalink":"https:\/\/humanists.scot\/celebrants\/gillian-monaghan\/","zoom":10,"extra_fields":{"post_excerpt":"Hi, I am Steven Muir and I live in Barrhead, near Paisley, with my wife Kate, between us we have five grown up children and numerous grandchildren!","post_content":"I\u2019m Gill and I\u2019m based in Leith, Edinburgh although I am a natural-born Dundonian.\r\n\r\n&nbsp;\r\n\r\nI\u2019ve had an interesting career trajectory, initially training in the performing arts, before embarking on a career in the music industry and then finally, training to be a teacher. I taught Drama for a number of years before moving into Support for Learning where my specialism has been working with neurodivergent young people.\r\n\r\n&nbsp;\r\n\r\nI came to Humanism through the experience of writing and performing readings at a number of friends and family weddings, and in delivering part of the eulogy at the funeral of my best friend. All of these ceremonies were Humanist ones and left me with such a positive feeling and progressive, life-affirming experience that I knew I wanted to explore the philosophy more. Humanism embodies all of the values that I hold dear - those of creativity, inclusivity, empathy, reason and tolerance. I see my role as a Humanist celebrant as a form of creative expression and I feel privileged to be entrusted with your story.\r\n\r\nA ceremony which honours exactly\u00a0<em>who<\/em>\u00a0people\u00a0<em>are<\/em>, filled with the best anecdotes, memories and unique flourishes is the best way to celebrate any major life milestone. Do you want your naming ceremony to include a colourful sand ceremony or bubble blowing ritual? Or a wedding ceremony conducted at the top of a hill or in the middle of a hedge maze? I am always up for anything a bit quirky and open to ideas!\r\n\r\nOutside of being a celebrant, I enjoy creative writing, going to gigs and I\u2019ve also started to learn Gaelic. My overarching passion however is travelling around and photographing Scotland. I know every corner of our beautiful country through my various jaunts and blogs about it, and am always more than happy to travel far and wide to conduct ceremonies. In fact, the more off-the-beaten track, the better!\r\n\r\nIf you connect with any of this and feel that I would be a good match for your ceremony, then I\u2019d love to hear from you!","post_title":"Gillian Monaghan","post_link":"https:\/\/humanists.scot\/celebrants\/gillian-monaghan\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Gillian Monaghan\" width=\"300\" height=\"205\" src=\"https:\/\/humanists.scot\/wp-content\/uploads\/Gillian-Monaghan-Profile-Pic-300x205.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"Celebrants, Central Scotland, Edinburgh &amp; Lothians, Funerals, Mid Scotland &amp; Fife, Type, Weddings","post_tags":"","%_edit_lock%":"1683665367:4","%_edit_last%":"4","%eg_sources_html5_mp4%":"","%eg_sources_youtube%":"","%eg_sources_vimeo%":"","%eg_sources_wistia%":"","%eg_sources_image%":"","%eg_sources_iframe%":"","%eg_sources_soundcloud%":"","%eg_vimeo_ratio%":"1","%eg_youtube_ratio%":"1","%eg_wistia_ratio%":"1","%eg_html5_ratio%":"1","%eg_soundcloud_ratio%":"1","%eg_sources_essgrid%":"","%eg_featured_grid%":"","%eg_settings_custom_meta_skin%":"","%eg_settings_custom_meta_element%":"","%eg_settings_custom_meta_setting%":"","%eg_settings_custom_meta_style%":"","%eg_custom_meta_216%":"true","%eg_votes_count%":"0","%_x_entry_body_css_class%":"","%_x_post_layout%":"off","%_x_entry_alternate_index_title%":"","%_x_entry_bg_image_full%":"","%_x_entry_bg_image_full_fade%":"750","%_x_entry_bg_image_full_duration%":"7500","%_x_quote_quote%":"","%_x_quote_cite%":"","%_x_link_url%":"","%_x_video_aspect_ratio%":"16:9","%_x_video_m4v%":"","%_x_video_ogv%":"","%_x_video_embed%":"","%_x_audio_mp3%":"","%_x_audio_ogg%":"","%_x_audio_embed%":"","%_wpgmp_location_address%":"Barrhead, UK","%_wpgmp_metabox_latitude%":"55.79671099999999","%_wpgmp_metabox_longitude%":"-4.397714000000001","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_metadesc%":"Available for Weddings and Funerals","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%_yoast_wpseo_primary_category%":"13","%_thumbnail_id%":"1892","%ninja_forms_form%":"19","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Celebrants, Central Scotland, Edinburgh &amp; Lothians, Funerals, Mid Scotland &amp; Fife, Type, Weddings","taxonomy=post_tag":"","taxonomy=post_format":""},"icon":"https:\/\/cha.urwinstudio.com\/wp-content\/uploads\/map-marker-1.png"},"id":1891,"infowindow_disable":false},{"source":"post","title":"Gareth Houston","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\"> \r\n<div class=\"boxPadded\">\r\n<p><a href=\"https:\/\/humanists.scot\/celebrants\/gareth-houston\/\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Gareth Houston\" width=\"300\" height=\"184\" src=\"https:\/\/humanists.scot\/wp-content\/uploads\/Gareth-Houston-Profile-Pic-300x184.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><\/a><\/p>\r\n<h3><a href=\"https:\/\/humanists.scot\/celebrants\/gareth-houston\/\">Gareth Houston<\/a><\/h3>\r\n<p>Hi, I am Steven Muir and I live in Barrhead, near Paisley, with my wife Kate, between us we have five grown up children and numerous grandchildren!<\/p>\r\n<a class=\"btn\" href=\"https:\/\/humanists.scot\/celebrants\/gareth-houston\/\">Celebrant Profile<\/a>\r\n<\/div>\r\n<\/div>","content":"Hi, I am Steven Muir and I live in Barrhead, near Paisley, with my wife Kate, between us we have five grown up children and numerous grandchildren!","address":"Barrhead, UK","location":{"lat":"55.79671099999999","lng":"-4.397714000000001","onclick_action":"marker","redirect_permalink":"https:\/\/humanists.scot\/celebrants\/gareth-houston\/","zoom":10,"extra_fields":{"post_excerpt":"Hi, I am Steven Muir and I live in Barrhead, near Paisley, with my wife Kate, between us we have five grown up children and numerous grandchildren!","post_content":"My name is Gareth and I\u2019m from Edinburgh. I have lived here most of my days and love it!\r\n\r\nFor most of my professional life I ran a lovely Edinburgh Guest House\r\n\r\nThe most rewarding aspect of running the guest house was making guests from all walks of life and all corners of the globe feel welcome, entertained and looked after.\u00a0 In conducting Humanist ceremonies I want to use those talents and more to help people through the significant moments in their lives.\r\n\r\nI\u2019m available to conduct weddings and funerals.\r\n\r\nI got married in 2014 and after attending a few Humanist ceremonies we knew we wanted have a Humanist wedding ceremony.\u00a0 We loved having the input on the ceremony and getting to share \u201cour story\u201d with our nearest and dearest. It gave us a unique experience that set the tone for a fantastic day.\u00a0 It was from there that I first started thinking about becoming a Celebrant myself.\r\n\r\nIt\u2019s a privilege to be able to help couples create a unique and personal ceremony. Tailoring the ceremony to suit their personality and allowing them the freedom to set the tone.\r\n\r\nThe rewarding aspect of conducting funerals is being able to help celebrate the life and personality of the person who has passed.\u00a0 And create a ceremony that accurately reflects their character and passions.","post_title":"Gareth Houston","post_link":"https:\/\/humanists.scot\/celebrants\/gareth-houston\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Gareth Houston\" width=\"300\" height=\"184\" src=\"https:\/\/humanists.scot\/wp-content\/uploads\/Gareth-Houston-Profile-Pic-300x184.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"Celebrants, Central Scotland, Edinburgh &amp; Lothians, Funerals, Glasgow, Mid Scotland &amp; Fife, Type, Weddings, West Scotland","post_tags":"","%_edit_lock%":"1683664699:4","%_edit_last%":"4","%eg_sources_html5_mp4%":"","%eg_sources_youtube%":"","%eg_sources_vimeo%":"","%eg_sources_wistia%":"","%eg_sources_image%":"","%eg_sources_iframe%":"","%eg_sources_soundcloud%":"","%eg_vimeo_ratio%":"1","%eg_youtube_ratio%":"1","%eg_wistia_ratio%":"1","%eg_html5_ratio%":"1","%eg_soundcloud_ratio%":"1","%eg_sources_essgrid%":"","%eg_featured_grid%":"","%eg_settings_custom_meta_skin%":"","%eg_settings_custom_meta_element%":"","%eg_settings_custom_meta_setting%":"","%eg_settings_custom_meta_style%":"","%eg_custom_meta_216%":"true","%eg_votes_count%":"0","%_x_entry_body_css_class%":"","%_x_post_layout%":"off","%_x_entry_alternate_index_title%":"","%_x_entry_bg_image_full%":"","%_x_entry_bg_image_full_fade%":"750","%_x_entry_bg_image_full_duration%":"7500","%_x_quote_quote%":"","%_x_quote_cite%":"","%_x_link_url%":"","%_x_video_aspect_ratio%":"16:9","%_x_video_m4v%":"","%_x_video_ogv%":"","%_x_video_embed%":"","%_x_audio_mp3%":"","%_x_audio_ogg%":"","%_x_audio_embed%":"","%_wpgmp_location_address%":"Barrhead, UK","%_wpgmp_metabox_latitude%":"55.79671099999999","%_wpgmp_metabox_longitude%":"-4.397714000000001","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_metadesc%":"Available for Weddings and Funerals","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_primary_category%":"13","%_thumbnail_id%":"1889","%ninja_forms_form%":"18","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Celebrants, Central Scotland, Edinburgh &amp; Lothians, Funerals, Glasgow, Mid Scotland &amp; Fife, Type, Weddings, West Scotland","taxonomy=post_tag":"","taxonomy=post_format":""},"icon":"https:\/\/cha.urwinstudio.com\/wp-content\/uploads\/map-marker-1.png"},"id":1888,"infowindow_disable":false},{"source":"post","title":"Steven Muir","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\"> \r\n<div class=\"boxPadded\">\r\n<p><a href=\"https:\/\/humanists.scot\/celebrants\/steven-muir\/\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Steven Muir\" width=\"300\" height=\"196\" src=\"https:\/\/humanists.scot\/wp-content\/uploads\/Steven_Muir_Profile_Pic1-300x196.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><\/a><\/p>\r\n<h3><a href=\"https:\/\/humanists.scot\/celebrants\/steven-muir\/\">Steven Muir<\/a><\/h3>\r\n<p>Hi, I am Steven Muir and I live in Barrhead, near Paisley, with my wife Kate, between us we have five grown up children and numerous grandchildren!<\/p>\r\n<a class=\"btn\" href=\"https:\/\/humanists.scot\/celebrants\/steven-muir\/\">Celebrant Profile<\/a>\r\n<\/div>\r\n<\/div>","content":"Hi, I am Steven Muir and I live in Barrhead, near Paisley, with my wife Kate, between us we have five grown up children and numerous grandchildren!","address":"Barrhead, UK","location":{"lat":"55.79671099999999","lng":"-4.397714000000001","onclick_action":"marker","redirect_permalink":"https:\/\/humanists.scot\/celebrants\/steven-muir\/","zoom":10,"extra_fields":{"post_excerpt":"Hi, I am Steven Muir and I live in Barrhead, near Paisley, with my wife Kate, between us we have five grown up children and numerous grandchildren!","post_content":"Hi, I am Steven Muir and I live in Barrhead, near Paisley, with my wife Kate, between us we have five grown up children and numerous grandchildren!\r\n\r\n&nbsp;\r\n\r\nAn Ayrshire lad, growing up in Prestwick, left school to join the Royal Navy followed by some time serving as a police officer in Ayrshire.\r\n\r\n&nbsp;\r\n\r\nI moved to London for three years to pursue a career in sales, later returning to Scotland where I have enjoyed various sales positions with different companies, travelling throughout the UK and finally retiring from sales in 2017.\r\n\r\n&nbsp;\r\n\r\nI have always been drawn to Humanism and it was a friends Humanist wedding that my interest was rekindled.\r\n\r\n&nbsp;\r\n\r\nIt made me reflect on what\u2019s important in life - family, friends and healthy respect for everything that life brings you.\r\n\r\n&nbsp;\r\n\r\nOn reflection it seems I have always been a humanist, I just hadn\u2019t put a label on it!\r\n\r\n&nbsp;\r\n\r\n<u>Funerals<\/u>\r\n\r\n&nbsp;\r\n\r\nI have always been struck by the way a humanist ceremony stands out as a celebration of life, filled with both tears and laughter, it gives a real reflection of that person\u2019s life.\r\n\r\n&nbsp;\r\n\r\nAs a celebrant with the Caledonian Humanist Association, my dedicated role is to work closely with you, to create a bespoke service that is personal, unique and dignified and one that honours the memory of your loved one.","post_title":"Steven Muir","post_link":"https:\/\/humanists.scot\/celebrants\/steven-muir\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Steven Muir\" width=\"300\" height=\"196\" src=\"https:\/\/humanists.scot\/wp-content\/uploads\/Steven_Muir_Profile_Pic1-300x196.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"Celebrants, Central Scotland, Edinburgh &amp; Lothians, Funerals, Glasgow, Mid Scotland &amp; Fife, Type, Weddings, West Scotland","post_tags":"","%_edit_lock%":"1666645055:4","%_edit_last%":"4","%eg_sources_html5_mp4%":"","%eg_sources_youtube%":"","%eg_sources_vimeo%":"","%eg_sources_wistia%":"","%eg_sources_image%":"","%eg_sources_iframe%":"","%eg_sources_soundcloud%":"","%eg_vimeo_ratio%":"1","%eg_youtube_ratio%":"1","%eg_wistia_ratio%":"1","%eg_html5_ratio%":"1","%eg_soundcloud_ratio%":"1","%eg_sources_essgrid%":"","%eg_featured_grid%":"","%eg_settings_custom_meta_skin%":"","%eg_settings_custom_meta_element%":"","%eg_settings_custom_meta_setting%":"","%eg_settings_custom_meta_style%":"","%eg_custom_meta_216%":"true","%eg_votes_count%":"0","%_x_entry_body_css_class%":"","%_x_post_layout%":"off","%_x_entry_alternate_index_title%":"","%_x_entry_bg_image_full%":"","%_x_entry_bg_image_full_fade%":"750","%_x_entry_bg_image_full_duration%":"7500","%_x_quote_quote%":"","%_x_quote_cite%":"","%_x_link_url%":"","%_x_video_aspect_ratio%":"16:9","%_x_video_m4v%":"","%_x_video_ogv%":"","%_x_video_embed%":"","%_x_audio_mp3%":"","%_x_audio_ogg%":"","%_x_audio_embed%":"","%_wpgmp_location_address%":"Barrhead, UK","%_wpgmp_metabox_latitude%":"55.79671099999999","%_wpgmp_metabox_longitude%":"-4.397714000000001","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_metadesc%":"Available for Weddings and Funerals","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_primary_category%":"13","%_thumbnail_id%":"1722","%ninja_forms_form%":"6","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Celebrants, Central Scotland, Edinburgh &amp; Lothians, Funerals, Glasgow, Mid Scotland &amp; Fife, Type, Weddings, West Scotland","taxonomy=post_tag":"","taxonomy=post_format":""},"icon":"https:\/\/cha.urwinstudio.com\/wp-content\/uploads\/map-marker-1.png"},"id":1711,"infowindow_disable":false},{"source":"post","title":"Joe Bloggs","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\"> \r\n<div class=\"boxPadded\">\r\n<p><a href=\"https:\/\/humanists.scot\/celebrants\/joe-bloggs\/\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Joe Bloggs\" width=\"300\" height=\"196\" src=\"https:\/\/humanists.scot\/wp-content\/uploads\/andy2-300x196.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><\/a><\/p>\r\n<h3><a href=\"https:\/\/humanists.scot\/celebrants\/joe-bloggs\/\">Joe Bloggs<\/a><\/h3>\r\n<p>Hi I'm Joe and I'm from Glasgow<\/p>\r\n<a class=\"btn\" href=\"https:\/\/humanists.scot\/celebrants\/joe-bloggs\/\">Celebrant Profile<\/a>\r\n<\/div>\r\n<\/div>","content":"Hi I'm Joe and I'm from Glasgow","address":"Glasgow, Scotland, UK","location":{"lat":"55.864237","lng":"-4.251806000000001","onclick_action":"marker","redirect_permalink":"https:\/\/humanists.scot\/celebrants\/joe-bloggs\/","zoom":10,"extra_fields":{"post_excerpt":"Hi I'm Joe and I'm from Glasgow","post_content":"Hi my name is Joe\r\n\r\n&nbsp;\r\n<blockquote>I live in Glasgow<\/blockquote>","post_title":"Joe Bloggs","post_link":"https:\/\/humanists.scot\/celebrants\/joe-bloggs\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Joe Bloggs\" width=\"300\" height=\"196\" src=\"https:\/\/humanists.scot\/wp-content\/uploads\/andy2-300x196.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"Celebrants, Central Scotland, Funerals, Glasgow, Location, Type","post_tags":"","%_edit_lock%":"1593599345:4","%_edit_last%":"4","%eg_sources_html5_mp4%":"","%eg_sources_html5_ogv%":"","%eg_sources_html5_webm%":"","%eg_sources_youtube%":"","%eg_sources_vimeo%":"","%eg_sources_wistia%":"","%eg_sources_image%":"","%eg_sources_iframe%":"","%eg_sources_soundcloud%":"","%eg_vimeo_ratio%":"1","%eg_youtube_ratio%":"1","%eg_wistia_ratio%":"1","%eg_html5_ratio%":"1","%eg_soundcloud_ratio%":"1","%eg_sources_essgrid%":"","%eg_featured_grid%":"","%eg_settings_custom_meta_skin%":"","%eg_settings_custom_meta_element%":"","%eg_settings_custom_meta_setting%":"","%eg_settings_custom_meta_style%":"","%eg_custom_meta_216%":"true","%eg_votes_count%":"0","%_x_entry_body_css_class%":"","%_x_post_layout%":"off","%_x_entry_alternate_index_title%":"","%_x_entry_bg_image_full%":"","%_x_entry_bg_image_full_fade%":"750","%_x_entry_bg_image_full_duration%":"7500","%_x_quote_quote%":"","%_x_quote_cite%":"","%_x_link_url%":"","%_x_video_aspect_ratio%":"16:9","%_x_video_m4v%":"","%_x_video_ogv%":"","%_x_video_embed%":"","%_x_audio_mp3%":"","%_x_audio_ogg%":"","%_x_audio_embed%":"","%_wpgmp_location_address%":"Glasgow, Scotland, UK","%_wpgmp_metabox_latitude%":"55.864237","%_wpgmp_metabox_longitude%":"-4.251806000000001","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_primary_category%":"13","%_thumbnail_id%":"1441","taxonomy=category":"Celebrants, Central Scotland, Funerals, Glasgow, Location, Type","taxonomy=post_tag":"","taxonomy=post_format":""},"icon":"https:\/\/cha.urwinstudio.com\/wp-content\/uploads\/map-marker-1.png"},"id":1618,"infowindow_disable":false},{"source":"post","title":"James Cattanach","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\"> \r\n<div class=\"boxPadded\">\r\n<p><a href=\"https:\/\/humanists.scot\/celebrants\/james-cattanach\/\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"James Cattanach\" width=\"300\" height=\"184\" src=\"https:\/\/humanists.scot\/wp-content\/uploads\/James-Cattanach-Profile-Pic-300x184.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><\/a><\/p>\r\n<h3><a href=\"https:\/\/humanists.scot\/celebrants\/james-cattanach\/\">James Cattanach<\/a><\/h3>\r\n<p>I've experienced all of the joy and celebratory buzz of organising a humanist wedding while also knowing the comfort that kind and eloquent words can bring at a time of great loss.<\/p>\r\n<a class=\"btn\" href=\"https:\/\/humanists.scot\/celebrants\/james-cattanach\/\">Celebrant Profile<\/a>\r\n<\/div>\r\n<\/div>","content":"I've experienced all of the joy and celebratory buzz of organising a humanist wedding while also knowing the comfort that kind and eloquent words can bring at a time of great loss.","address":"Stirling, UK","location":{"lat":"56.1165227","lng":"-3.93690289999995","onclick_action":"marker","redirect_permalink":"https:\/\/humanists.scot\/celebrants\/james-cattanach\/","zoom":10,"extra_fields":{"post_excerpt":"I've experienced all of the joy and celebratory buzz of organising a humanist wedding while also knowing the comfort that kind and eloquent words can bring at a time of great loss.","post_content":"I\u2019m James and although born and brought up as a \u201cFalkirk Bairn\u201d, I have lived most of my life in the Stirling area. I\u2019m married with a son and daughter who have their own families now, and between them have provided me with five beautiful granddaughters!!\r\n\r\nI joined the Caledonian Humanist Association several years ago after attending a number of humanist ceremonies and finding them so much more meaningful and personal than other services. It therefore seemed a natural progression to go on and train as a celebrant.\r\n\r\nMy personal interests include fishing, reading and watching football \u2013 my playing days are long gone!!\r\n\r\n<strong>Funerals<\/strong>\r\n\r\nEach person is unique, as is the story of their life. A funeral ceremony should reflect that uniqueness and, at a time of great sadness, should still be able to celebrate that life.\r\n\r\nVery often memories of someone are about everyday things they used to do and funny things they would say. They are about experiences shared and kindnesses done. A funeral ceremony which tells how they lived their life can offer comfort to family and friends and lift their hearts a little through shared memories.\r\n\r\n<strong>Weddings<\/strong>\r\n\r\nWhat is in a humanist ceremony? Pretty much anything you want as it is your big day!\r\n\r\nIt can short and simple and formal; or perhaps contain more about your story as a couple and be more light-hearted and informal; or be a mixture of all of these things. The important element in all cases is that it describes your love for and commitment to each other, and how those have brought you to this happy stage in your relationship.\r\n\r\nMy role is to help guide you through each stage of the process of preparing for the ceremony from an initial meeting through to the big day. We will work together to create a very personal ceremony which will be as unique as you are.","post_title":"James Cattanach","post_link":"https:\/\/humanists.scot\/celebrants\/james-cattanach\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"James Cattanach\" width=\"300\" height=\"184\" src=\"https:\/\/humanists.scot\/wp-content\/uploads\/James-Cattanach-Profile-Pic-300x184.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"Celebrants, Central Scotland, Edinburgh &amp; Lothians, Funerals, Glasgow, Highlands &amp; Islands, Location, Mid Scotland &amp; Fife, Naming, North East Scotland, South Scotland, Type, Weddings, West Scotland","post_tags":"","%_edit_last%":"4","%_edit_lock%":"1682629559:4","%_thumbnail_id%":"1860","%slide_template%":"","%eg_sources_html5_mp4%":"","%eg_sources_html5_ogv%":"","%eg_sources_html5_webm%":"","%eg_sources_youtube%":"","%eg_sources_vimeo%":"","%eg_sources_wistia%":"","%eg_sources_image%":"","%eg_sources_iframe%":"","%eg_sources_soundcloud%":"","%eg_vimeo_ratio%":"1","%eg_youtube_ratio%":"1","%eg_wistia_ratio%":"1","%eg_html5_ratio%":"1","%eg_soundcloud_ratio%":"1","%eg_sources_revslider%":"","%eg_sources_essgrid%":"","%eg_featured_grid%":"","%eg_settings_custom_meta_skin%":"","%eg_settings_custom_meta_element%":"","%eg_settings_custom_meta_setting%":"","%eg_settings_custom_meta_style%":"","%eg_custom_meta_216%":"true","%eg_votes_count%":"0","%_x_entry_body_css_class%":"","%_x_post_layout%":"off","%_x_entry_alternate_index_title%":"","%_x_entry_bg_image_full%":"","%_x_entry_bg_image_full_fade%":"750","%_x_entry_bg_image_full_duration%":"7500","%_x_quote_quote%":"","%_x_quote_cite%":"","%_x_link_url%":"","%_x_video_aspect_ratio%":"16:9","%_x_video_m4v%":"","%_x_video_ogv%":"","%_x_video_embed%":"","%_x_audio_mp3%":"","%_x_audio_ogg%":"","%_x_audio_embed%":"","%_wpgmp_location_address%":"Stirling, UK","%_wpgmp_metabox_latitude%":"56.1165227","%_wpgmp_metabox_longitude%":"-3.93690289999995","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_primary_category%":"13","%ninja_forms_form%":"8","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%_yoast_wpseo_wordproof_timestamp%":"","%_wp_old_slug%":"mags-kearns-griffin","taxonomy=category":"Celebrants, Central Scotland, Edinburgh &amp; Lothians, Funerals, Glasgow, Highlands &amp; Islands, Location, Mid Scotland &amp; Fife, Naming, North East Scotland, South Scotland, Type, Weddings, West Scotland","taxonomy=post_tag":"","taxonomy=post_format":""},"icon":"https:\/\/cha.urwinstudio.com\/wp-content\/uploads\/map-marker-1.png"},"id":1501,"infowindow_disable":false},{"source":"post","title":"Jacqui Clarke","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\"> \r\n<div class=\"boxPadded\">\r\n<p><a href=\"https:\/\/humanists.scot\/celebrants\/jacqui-clarke\/\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Jacqui Clarke\" width=\"300\" height=\"196\" src=\"https:\/\/humanists.scot\/wp-content\/uploads\/jacqui-300x196.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><\/a><\/p>\r\n<h3><a href=\"https:\/\/humanists.scot\/celebrants\/jacqui-clarke\/\">Jacqui Clarke<\/a><\/h3>\r\n<p>I was amazed at the flexibility of every aspect of the wedding ceremony and the compassion and uplifting nature of funeral ceremonies. I was so inspired that I decided to train to be a celebrant.<\/p>\r\n<a class=\"btn\" href=\"https:\/\/humanists.scot\/celebrants\/jacqui-clarke\/\">Celebrant Profile<\/a>\r\n<\/div>\r\n<\/div>","content":"I was amazed at the flexibility of every aspect of the wedding ceremony and the compassion and uplifting nature of funeral ceremonies. I was so inspired that I decided to train to be a celebrant.","address":"Drumnadrochit, Inverness, UK","location":{"lat":"57.334499","lng":"-4.478961000000027","onclick_action":"marker","redirect_permalink":"https:\/\/humanists.scot\/celebrants\/jacqui-clarke\/","zoom":10,"extra_fields":{"post_excerpt":"I was amazed at the flexibility of every aspect of the wedding ceremony and the compassion and uplifting nature of funeral ceremonies. I was so inspired that I decided to train to be a celebrant.","post_content":"I\u2019m Jacqui and I live in the little picturesque village of Drumnadrochit, which is nestled on the side of Loch Ness in the Scottish Highlands. However, I\u2019m originally from Blantyre in South Lanarkshire, so originally from the same town as the world famous Scottish explorer, Dr David Livingstone and now a neighbour of the world famous Scottish monster, Nessie!\r\n\r\nThere have been many places in between though! After graduating from Jordanhill College in 1993 with a B.Ed (Hons) in Primary Education, I left to work in Abu Dhabi. My plan was to go for four years and save up enough money to put central heating in my little flat and buy a Volvo c30. None of those things happened of course! I came back last year, 25 years later, with a husband and two children at university and a Mini instead.\r\n<blockquote>I was amazed at the flexibility of every aspect of the wedding ceremony and the compassion and uplifting nature of funeral ceremonies. I was so inspired that I decided to train to be a celebrant.<\/blockquote>\r\nLike many people, it has taken me my whole life to realise that I\u2019ve always been a Humanist. Leaving the familiarity of my family, friends and community all those years ago wasn\u2019t easy but it was the kind and welcoming nature of the expat community made up of people from different countries, with different languages, beliefs, customs, traditions and so on that made it easier. Our differences were never an issue. Instead it was the understanding that no matter where in the world you come from we all thrive where there is kindness and understanding.\r\n\r\nOver the past six or seven years, I began to hear so many positive things about Humanist weddings and funerals. So, I decided to investigate a bit further. I was amazed at the flexibility of every aspect of the wedding ceremony and the compassion and uplifting nature of funeral ceremonies. I was so inspired that I decided to train to be a celebrant.\r\n\r\nI consider it an absolute privilege to work with families who have been recently bereaved. I understand the devastation families feel when they lose a loved one. I understand the confusion, disbelief and shock of having your world turned upside-down, yet having to \u2018act normal\u2019 while you go through the necessary arrangements. I would be there to ensure that the life of your loved one is celebrated in the way that they would have wanted and that you would have the opportunity to say goodbye in the way that will give you comfort when you reflect on the ceremony in times to come.","post_title":"Jacqui Clarke","post_link":"https:\/\/humanists.scot\/celebrants\/jacqui-clarke\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Jacqui Clarke\" width=\"300\" height=\"196\" src=\"https:\/\/humanists.scot\/wp-content\/uploads\/jacqui-300x196.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"Celebrants, Funerals, Highlands &amp; Islands, Location, Naming, Type, Weddings","post_tags":"","%_edit_last%":"4","%_edit_lock%":"1666649060:4","%_thumbnail_id%":"1499","%slide_template%":"","%eg_sources_html5_mp4%":"","%eg_sources_html5_ogv%":"","%eg_sources_html5_webm%":"","%eg_sources_youtube%":"","%eg_sources_vimeo%":"","%eg_sources_wistia%":"","%eg_sources_image%":"","%eg_sources_iframe%":"","%eg_sources_soundcloud%":"","%eg_vimeo_ratio%":"1","%eg_youtube_ratio%":"1","%eg_wistia_ratio%":"1","%eg_html5_ratio%":"1","%eg_soundcloud_ratio%":"1","%eg_sources_revslider%":"","%eg_sources_essgrid%":"","%eg_featured_grid%":"","%eg_settings_custom_meta_skin%":"","%eg_settings_custom_meta_element%":"","%eg_settings_custom_meta_setting%":"","%eg_settings_custom_meta_style%":"","%eg_custom_meta_216%":"true","%eg_votes_count%":"0","%_x_entry_body_css_class%":"","%_x_post_layout%":"off","%_x_entry_alternate_index_title%":"","%_x_entry_bg_image_full%":"","%_x_entry_bg_image_full_fade%":"750","%_x_entry_bg_image_full_duration%":"7500","%_x_quote_quote%":"","%_x_quote_cite%":"","%_x_link_url%":"","%_x_video_aspect_ratio%":"16:9","%_x_video_m4v%":"","%_x_video_ogv%":"","%_x_video_embed%":"","%_x_audio_mp3%":"","%_x_audio_ogg%":"","%_x_audio_embed%":"","%_wpgmp_location_address%":"Drumnadrochit, Inverness, UK","%_wpgmp_metabox_latitude%":"57.334499","%_wpgmp_metabox_longitude%":"-4.478961000000027","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_primary_category%":"13","%ninja_forms_form%":"9","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Celebrants, Funerals, Highlands &amp; Islands, Location, Naming, Type, Weddings","taxonomy=post_tag":"","taxonomy=post_format":""},"icon":"https:\/\/cha.urwinstudio.com\/wp-content\/uploads\/map-marker-1.png"},"id":1498,"infowindow_disable":false},{"source":"post","title":"David Clarke","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\"> \r\n<div class=\"boxPadded\">\r\n<p><a href=\"https:\/\/humanists.scot\/celebrants\/david-clarke\/\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"David Clarke\" width=\"300\" height=\"196\" src=\"https:\/\/humanists.scot\/wp-content\/uploads\/david-300x196.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><\/a><\/p>\r\n<h3><a href=\"https:\/\/humanists.scot\/celebrants\/david-clarke\/\">David Clarke<\/a><\/h3>\r\n<p>Like many people I\u2019ve always been a humanist but have only recently trained to become a celebrant.<\/p>\r\n<a class=\"btn\" href=\"https:\/\/humanists.scot\/celebrants\/david-clarke\/\">Celebrant Profile<\/a>\r\n<\/div>\r\n<\/div>","content":"Like many people I\u2019ve always been a humanist but have only recently trained to become a celebrant.","address":"Aviemore, UK","location":{"lat":"57.19448999999999","lng":"-3.8238119999999753","onclick_action":"marker","redirect_permalink":"https:\/\/humanists.scot\/celebrants\/david-clarke\/","zoom":10,"extra_fields":{"post_excerpt":"Like many people I\u2019ve always been a humanist but have only recently trained to become a celebrant.","post_content":"I\u2019m David and, like many people I\u2019ve always been a humanist but have only recently trained to become a celebrant.\r\n\r\nI have had a home in the Highlands for over 16 years but in 2018, after 25 years teaching biology and chemistry in the UAE, Bahrain and Belgium, I came back to settle in Scotland for good.\r\n\r\nI\u2019m continuing to teach but am looking forward to putting my training into practice.","post_title":"David Clarke","post_link":"https:\/\/humanists.scot\/celebrants\/david-clarke\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"David Clarke\" width=\"300\" height=\"196\" src=\"https:\/\/humanists.scot\/wp-content\/uploads\/david-300x196.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"Celebrants, Highlands &amp; Islands, Location, Type, Weddings","post_tags":"","%_edit_last%":"4","%_edit_lock%":"1666649980:4","%_thumbnail_id%":"1496","%slide_template%":"","%eg_sources_html5_mp4%":"","%eg_sources_html5_ogv%":"","%eg_sources_html5_webm%":"","%eg_sources_youtube%":"","%eg_sources_vimeo%":"","%eg_sources_wistia%":"","%eg_sources_image%":"","%eg_sources_iframe%":"","%eg_sources_soundcloud%":"","%eg_vimeo_ratio%":"1","%eg_youtube_ratio%":"1","%eg_wistia_ratio%":"1","%eg_html5_ratio%":"1","%eg_soundcloud_ratio%":"1","%eg_sources_revslider%":"","%eg_sources_essgrid%":"","%eg_featured_grid%":"","%eg_settings_custom_meta_skin%":"","%eg_settings_custom_meta_element%":"","%eg_settings_custom_meta_setting%":"","%eg_settings_custom_meta_style%":"","%eg_custom_meta_216%":"true","%eg_votes_count%":"0","%_x_entry_body_css_class%":"","%_x_post_layout%":"off","%_x_entry_alternate_index_title%":"","%_x_entry_bg_image_full%":"","%_x_entry_bg_image_full_fade%":"750","%_x_entry_bg_image_full_duration%":"7500","%_x_quote_quote%":"","%_x_quote_cite%":"","%_x_link_url%":"","%_x_video_aspect_ratio%":"16:9","%_x_video_m4v%":"","%_x_video_ogv%":"","%_x_video_embed%":"","%_x_audio_mp3%":"","%_x_audio_ogg%":"","%_x_audio_embed%":"","%_wpgmp_location_address%":"Aviemore, UK","%_wpgmp_metabox_latitude%":"57.19448999999999","%_wpgmp_metabox_longitude%":"-3.8238119999999753","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_primary_category%":"13","%ninja_forms_form%":"10","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Celebrants, Highlands &amp; Islands, Location, Type, Weddings","taxonomy=post_tag":"","taxonomy=post_format":""},"icon":"https:\/\/cha.urwinstudio.com\/wp-content\/uploads\/map-marker-1.png"},"id":1495,"infowindow_disable":false},{"source":"post","title":"Nikki Auld","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\"> \r\n<div class=\"boxPadded\">\r\n<p><a href=\"https:\/\/humanists.scot\/celebrants\/nikki-auld\/\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Nikki Auld\" width=\"300\" height=\"196\" src=\"https:\/\/humanists.scot\/wp-content\/uploads\/nikki-300x196.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><\/a><\/p>\r\n<h3><a href=\"https:\/\/humanists.scot\/celebrants\/nikki-auld\/\">Nikki Auld<\/a><\/h3>\r\n<p>I have wanted to be a celebrant for many years now and now I have finally trained, I am delighted to be following my heart once more, down this very rewarding path.<\/p>\r\n<a class=\"btn\" href=\"https:\/\/humanists.scot\/celebrants\/nikki-auld\/\">Celebrant Profile<\/a>\r\n<\/div>\r\n<\/div>","content":"I have wanted to be a celebrant for many years now and now I have finally trained, I am delighted to be following my heart once more, down this very rewarding path.","address":"George Square, Glasgow, UK","location":{"lat":"55.8611637","lng":"-4.250165100000004","onclick_action":"marker","redirect_permalink":"https:\/\/humanists.scot\/celebrants\/nikki-auld\/","zoom":10,"extra_fields":{"post_excerpt":"I have wanted to be a celebrant for many years now and now I have finally trained, I am delighted to be following my heart once more, down this very rewarding path.","post_content":"Hi, my name is Nikki. I was born in Edinburgh, but following my heart, headed west to Glasgow and have lived there over half my life now. I love both of these fabulous cities as they are unique in there own way.\r\n\r\nI have been a performer for over 30 years, working in stage, television and radio. I worked for the children\u2019s theatre company, The Happy Gang, for 8 years touring some of the grandest of theatres to the cosiest of village halls, and was a presenter for BBC children\u2019s television. I now sing with The Swingcats, a retro three-part harmony group.\r\n<blockquote>I have wanted to be a celebrant for many years now and now I have finally trained, I am delighted to be following my heart once more, down this very rewarding path.<\/blockquote>\r\nBeing a performer, I have had many jobs along the way, many of them working with the public and in various different walks of life. I enjoy engaging with people and listening to the stories of their lives.\r\n\r\nI was raised as a Humanist, but at the time did not really realise that is what it was!\u00a0 One day, after having a Humanist for my father\u2019s funeral, I began to read what Humanism meant and it totally clicked. I realised that this is what my father had instilled in me from a little child and on into my adulthood.\r\n\r\nI have wanted to be a celebrant for many years now and now I have finally trained, I am delighted to be following my heart once more, down this very rewarding path. To me it is important at a funeral, that the person is remembered in a warm and humane way and even though there is, of course, bound to be tears, I would like to think maybe there will be some laughs too and hopefully at the end of it all, people will leave with their hearts lifted a little and warmed by memories shared.\r\n\r\nIn my spare time I love the outdoors, especially the sea, old movies, theatre and star-gazing (when you can see them!)","post_title":"Nikki Auld","post_link":"https:\/\/humanists.scot\/celebrants\/nikki-auld\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Nikki Auld\" width=\"300\" height=\"196\" src=\"https:\/\/humanists.scot\/wp-content\/uploads\/nikki-300x196.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"Celebrants, Central Scotland, Edinburgh &amp; Lothians, Funerals, Glasgow, Location, Type","post_tags":"","%_edit_last%":"4","%_edit_lock%":"1666730925:4","%_thumbnail_id%":"1490","%slide_template%":"","%eg_sources_html5_mp4%":"","%eg_sources_html5_ogv%":"","%eg_sources_html5_webm%":"","%eg_sources_youtube%":"","%eg_sources_vimeo%":"","%eg_sources_wistia%":"","%eg_sources_image%":"","%eg_sources_iframe%":"","%eg_sources_soundcloud%":"","%eg_vimeo_ratio%":"1","%eg_youtube_ratio%":"1","%eg_wistia_ratio%":"1","%eg_html5_ratio%":"1","%eg_soundcloud_ratio%":"1","%eg_sources_revslider%":"","%eg_sources_essgrid%":"","%eg_featured_grid%":"","%eg_settings_custom_meta_skin%":"","%eg_settings_custom_meta_element%":"","%eg_settings_custom_meta_setting%":"","%eg_settings_custom_meta_style%":"","%eg_custom_meta_216%":"true","%eg_votes_count%":"0","%_x_entry_body_css_class%":"","%_x_post_layout%":"off","%_x_entry_alternate_index_title%":"","%_x_entry_bg_image_full%":"","%_x_entry_bg_image_full_fade%":"750","%_x_entry_bg_image_full_duration%":"7500","%_x_quote_quote%":"","%_x_quote_cite%":"","%_x_link_url%":"","%_x_video_aspect_ratio%":"16:9","%_x_video_m4v%":"","%_x_video_ogv%":"","%_x_video_embed%":"","%_x_audio_mp3%":"","%_x_audio_ogg%":"","%_x_audio_embed%":"","%_wpgmp_location_address%":"George Square, Glasgow, UK","%_wpgmp_metabox_latitude%":"55.8611637","%_wpgmp_metabox_longitude%":"-4.250165100000004","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_primary_category%":"13","%ninja_forms_form%":"13","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Celebrants, Central Scotland, Edinburgh &amp; Lothians, Funerals, Glasgow, Location, Type","taxonomy=post_tag":"","taxonomy=post_format":""},"icon":"https:\/\/cha.urwinstudio.com\/wp-content\/uploads\/map-marker-1.png"},"id":1489,"infowindow_disable":false},{"source":"post","title":"Adrienne Roberston","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\"> \r\n<div class=\"boxPadded\">\r\n<p><a href=\"https:\/\/humanists.scot\/celebrants\/adrienne-roberston\/\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Adrienne Roberston\" width=\"300\" height=\"196\" src=\"https:\/\/humanists.scot\/wp-content\/uploads\/adrienne-300x196.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><\/a><\/p>\r\n<h3><a href=\"https:\/\/humanists.scot\/celebrants\/adrienne-roberston\/\">Adrienne Roberston<\/a><\/h3>\r\n<p>I decided to become a celebrant after attending humanist ceremonies and noting how much more personal and meaningful they seemed to be.<\/p>\r\n<a class=\"btn\" href=\"https:\/\/humanists.scot\/celebrants\/adrienne-roberston\/\">Celebrant Profile<\/a>\r\n<\/div>\r\n<\/div>","content":"I decided to become a celebrant after attending humanist ceremonies and noting how much more personal and meaningful they seemed to be.","address":"Largs, UK","location":{"lat":"55.79333500000001","lng":"-4.867277999999942","onclick_action":"marker","redirect_permalink":"https:\/\/humanists.scot\/celebrants\/adrienne-roberston\/","zoom":10,"extra_fields":{"post_excerpt":"I decided to become a celebrant after attending humanist ceremonies and noting how much more personal and meaningful they seemed to be.","post_content":"Hi, I\u2019m Adrienne Robertson.\r\n\r\nI am originally from Ayrshire, having retired back home to Largs in the past few years after living and working in Shetland for 10 years. My family and friends are all close by and I am very happy to be home.\r\n<blockquote>I decided to become a celebrant after attending humanist ceremonies and noting how much more personal and meaningful they seemed to be. In particular I felt that they were reassuringly respectful, sincere, warm and dignified... and often with a wee bit of humour to be found.<\/blockquote>\r\nI was married in 2011 for one year, after which my husband suddenly passed away. I have recently found love again with a wonderful man who is hugely supportive of my recent career move. I do not have children, but spent my previous career working with young people, and have experienced my fair share of teenage tantrums!\r\n\r\nMy previous career was in social work, where I worked mainly with children and families, and latterly with criminal justice. I miss the clients and colleagues, but not so much the politics and paperwork! I have a degree in Social Studies with a diploma in Social Work, and recently spent time volunteering as a member of the local Children\u2019s Panel.\r\n\r\nOutside of work, family and walking my wee shitzu Alfie, I enjoy music (I sing and play piano \u2013 both badly but enthusiastically!), painting, reading poetry and \u2013 much like the rest of the nation - find myself getting more and more interested in politics. I love chocolate, tea and interesting people, and I like to travel as much as budget, time and Alfie allow.\r\n\r\nBut its not about me, or even Alfie. Its about whether this gives you a sense of whether I may be the right celebrant for you. Working together would be entirely about the person the ceremony is about, my role is to work alongside you and to create an occasion that is right for you and your family.","post_title":"Adrienne Roberston","post_link":"https:\/\/humanists.scot\/celebrants\/adrienne-roberston\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Adrienne Roberston\" width=\"300\" height=\"196\" src=\"https:\/\/humanists.scot\/wp-content\/uploads\/adrienne-300x196.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"Celebrants, Funerals, Location, Naming, South Scotland, Type, Weddings, West Scotland","post_tags":"","%_edit_last%":"4","%_edit_lock%":"1666730242:4","%_thumbnail_id%":"1487","%slide_template%":"","%eg_sources_html5_mp4%":"","%eg_sources_html5_ogv%":"","%eg_sources_html5_webm%":"","%eg_sources_youtube%":"","%eg_sources_vimeo%":"","%eg_sources_wistia%":"","%eg_sources_image%":"","%eg_sources_iframe%":"","%eg_sources_soundcloud%":"","%eg_vimeo_ratio%":"1","%eg_youtube_ratio%":"1","%eg_wistia_ratio%":"1","%eg_html5_ratio%":"1","%eg_soundcloud_ratio%":"1","%eg_sources_revslider%":"","%eg_sources_essgrid%":"","%eg_featured_grid%":"","%eg_settings_custom_meta_skin%":"","%eg_settings_custom_meta_element%":"","%eg_settings_custom_meta_setting%":"","%eg_settings_custom_meta_style%":"","%eg_custom_meta_216%":"true","%eg_votes_count%":"0","%_x_entry_body_css_class%":"","%_x_post_layout%":"off","%_x_entry_alternate_index_title%":"","%_x_entry_bg_image_full%":"","%_x_entry_bg_image_full_fade%":"750","%_x_entry_bg_image_full_duration%":"7500","%_x_quote_quote%":"","%_x_quote_cite%":"","%_x_link_url%":"","%_x_video_aspect_ratio%":"16:9","%_x_video_m4v%":"","%_x_video_ogv%":"","%_x_video_embed%":"","%_x_audio_mp3%":"","%_x_audio_ogg%":"","%_x_audio_embed%":"","%_wpgmp_location_address%":"Largs, UK","%_wpgmp_metabox_latitude%":"55.79333500000001","%_wpgmp_metabox_longitude%":"-4.867277999999942","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_primary_category%":"13","%ninja_forms_form%":"12","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Celebrants, Funerals, Location, Naming, South Scotland, Type, Weddings, West Scotland","taxonomy=post_tag":"","taxonomy=post_format":""},"icon":"https:\/\/cha.urwinstudio.com\/wp-content\/uploads\/map-marker-1.png"},"id":1486,"infowindow_disable":false},{"source":"post","title":"Victoria Johnston","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\"> \r\n<div class=\"boxPadded\">\r\n<p><a href=\"https:\/\/humanists.scot\/celebrants\/victoria-johnston\/\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Victoria Johnston\" width=\"300\" height=\"166\" src=\"https:\/\/humanists.scot\/wp-content\/uploads\/PXL_20220909_133805052-300x166.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><\/a><\/p>\r\n<h3><a href=\"https:\/\/humanists.scot\/celebrants\/victoria-johnston\/\">Victoria Johnston<\/a><\/h3>\r\n<p>There can be no greater privilege in life than telling someone\u2019s life story whilst offering comfort to the family at such a difficult and emotional time.<\/p>\r\n<a class=\"btn\" href=\"https:\/\/humanists.scot\/celebrants\/victoria-johnston\/\">Celebrant Profile<\/a>\r\n<\/div>\r\n<\/div>","content":"There can be no greater privilege in life than telling someone\u2019s life story whilst offering comfort to the family at such a difficult and emotional time.","address":"Paisley, UK","location":{"lat":"55.847258","lng":"-4.440113999999999","onclick_action":"marker","redirect_permalink":"https:\/\/humanists.scot\/celebrants\/victoria-johnston\/","zoom":10,"extra_fields":{"post_excerpt":"There can be no greater privilege in life than telling someone\u2019s life story whilst offering comfort to the family at such a difficult and emotional time.","post_content":"Hi, I\u2019m Victoria and I love being a celebrant, meeting people and being a part of the milestone occasions in their lives.\r\n\r\nI\u2019m based in Paisley and went to school in the town. I went to the University of Stirling and developed a great love for that part of the country. I\u2019ve been married for 20 years and I\u2019m a mum to three (now scarily!) grown up children so I appreciate and understand the ties that bond families and the complexity of the relationships within the family unit.\r\n\r\nI\u2019ve had lots of different jobs over the years, but people and communication have been at the heart of everything I\u2019ve done. I\u2019ve been a part of the morning broadcast team at Radio Scotland for over 15 years, interviewing and meeting people from all walks of life. I\u2019ve learned how to put people at ease when they feel nervous or anxious \u2013 nothing gets the adrenalin going like the glow of an \u2018on-air\u2019 mic in a studio.\r\n\r\nI first became interested in becoming a celebrant when my friend asked me to perform her wedding ceremony \u2013 I couldn\u2019t perform the ceremony, but I was able to write and deliver a bespoke, personalised reading on the day which was an honour. It wasn\u2019t until a few years later when my children were older, and I had more time, that I was able to pursue my dream before becoming a part of the team at the Caledonian Humanist Association.\r\n\r\nPeople often ask me what made me want to deliver funerals, they understand that weddings and naming days are joyous events but are surprised that I\u2019ve always wanted to deliver funerals. For me, being involved in any significant life event is a privilege but to be trusted with writing and telling the story of someone\u2019s life is an absolute honour. Every life is individual and unique and deserves to be treated as such, and so I approach each funeral and family with respect, compassion, and empathy.\r\n\r\nA funeral is the last gesture a family can give a loved one and it\u2019s my job to ensure that the ceremony reflects the personality and impact of a loved one. I take great pride in curating poems and readings which fit beautifully into a personalised ceremony.\r\n\r\n&nbsp;","post_title":"Victoria Johnston","post_link":"https:\/\/humanists.scot\/celebrants\/victoria-johnston\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Victoria Johnston\" width=\"300\" height=\"166\" src=\"https:\/\/humanists.scot\/wp-content\/uploads\/PXL_20220909_133805052-300x166.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"Celebrants, Central Scotland, Edinburgh &amp; Lothians, Funerals, Glasgow, Location, Mid Scotland &amp; Fife, South Scotland, Type","post_tags":"","%_edit_last%":"4","%_edit_lock%":"1667859858:4","%_thumbnail_id%":"1831","%slide_template%":"","%eg_sources_html5_mp4%":"","%eg_sources_html5_ogv%":"","%eg_sources_html5_webm%":"","%eg_sources_youtube%":"","%eg_sources_vimeo%":"","%eg_sources_wistia%":"","%eg_sources_image%":"","%eg_sources_iframe%":"","%eg_sources_soundcloud%":"","%eg_vimeo_ratio%":"1","%eg_youtube_ratio%":"1","%eg_wistia_ratio%":"1","%eg_html5_ratio%":"1","%eg_soundcloud_ratio%":"1","%eg_sources_revslider%":"","%eg_sources_essgrid%":"","%eg_featured_grid%":"","%eg_settings_custom_meta_skin%":"","%eg_settings_custom_meta_element%":"","%eg_settings_custom_meta_setting%":"","%eg_settings_custom_meta_style%":"","%eg_custom_meta_216%":"true","%eg_votes_count%":"0","%_x_entry_body_css_class%":"","%_x_post_layout%":"off","%_x_entry_alternate_index_title%":"","%_x_entry_bg_image_full%":"","%_x_entry_bg_image_full_fade%":"750","%_x_entry_bg_image_full_duration%":"7500","%_x_quote_quote%":"","%_x_quote_cite%":"","%_x_link_url%":"","%_x_video_aspect_ratio%":"16:9","%_x_video_m4v%":"","%_x_video_ogv%":"","%_x_video_embed%":"","%_x_audio_mp3%":"","%_x_audio_ogg%":"","%_x_audio_embed%":"","%_wpgmp_location_address%":"Paisley, UK","%_wpgmp_metabox_latitude%":"55.847258","%_wpgmp_metabox_longitude%":"-4.440113999999999","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_primary_category%":"13","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%_wp_old_slug%":"aileen-massie","%_yoast_wpseo_wordproof_timestamp%":"","%ninja_forms_form%":"7","taxonomy=category":"Celebrants, Central Scotland, Edinburgh &amp; Lothians, Funerals, Glasgow, Location, Mid Scotland &amp; Fife, South Scotland, Type","taxonomy=post_tag":"","taxonomy=post_format":""},"icon":"https:\/\/cha.urwinstudio.com\/wp-content\/uploads\/map-marker-1.png"},"id":1483,"infowindow_disable":false},{"source":"post","title":"Mark McCabe","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\"> \r\n<div class=\"boxPadded\">\r\n<p><a href=\"https:\/\/humanists.scot\/celebrants\/mark-mccabe\/\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Mark McCabe\" width=\"300\" height=\"196\" src=\"https:\/\/humanists.scot\/wp-content\/uploads\/mark-300x196.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><\/a><\/p>\r\n<h3><a href=\"https:\/\/humanists.scot\/celebrants\/mark-mccabe\/\">Mark McCabe<\/a><\/h3>\r\n<p>As a Humanist Celebrant my dedicated role is to work closely with you, to create a bespoke service that you will be proud of.<\/p>\r\n<a class=\"btn\" href=\"https:\/\/humanists.scot\/celebrants\/mark-mccabe\/\">Celebrant Profile<\/a>\r\n<\/div>\r\n<\/div>","content":"As a Humanist Celebrant my dedicated role is to work closely with you, to create a bespoke service that you will be proud of.","address":"Cumbernauld, Glasgow, UK","location":{"lat":"55.945668","lng":"-3.992534","onclick_action":"marker","redirect_permalink":"https:\/\/humanists.scot\/celebrants\/mark-mccabe\/","zoom":10,"extra_fields":{"post_excerpt":"As a Humanist Celebrant my dedicated role is to work closely with you, to create a bespoke service that you will be proud of.","post_content":"My name is Mark McCabe, and I have been married to my wife and best friend Irene since 1986, and we have two wonderful talented sons. I was a Police Constable with the British Transport Police for twenty-six years, I worked as a Family Liaison Officer for fourteen years, working with bereaved families during Police investigations, including the case to identify body 115, the last unidentified victim from the Kings Cross fire. I worked as a Police trainer over a long period of time, delivering in house training. I also worked as a school liaison officer, delivering safety inputs to pupils of all ages, and wrote a children\u2019s safety book.\r\n\r\nI left the Police in 2014 and retrained as a Trainer, and work with Pitmans Training delivering corporate training to businesses throughout Scotland on a freelance basis. I also work on a relief basis with Adults with special needs, which is both challenging and rewarding.\r\n\r\nAs a Humanist Celebrant my dedicated role is to work closely with you, to create a bespoke service that you will be proud of.\r\n<h2>Funerals<\/h2>\r\nI attended my first Humanist funeral service in 2004, and I was amazed that the service was all about the deceased person in his families own words. It was an uplifting experience for everyone, there were tears, and laughter, stories old and new, it was clear this was a celebration of a life lived. This sums up my approach in helping you plan a loved ones Funeral service.\r\n<h2>Weddings<\/h2>\r\nThis is your big day, and your wedding celebration is a blank canvass. You both are the artists so bring your own unique style and colour to this day and paint a picture that your family and friends will talk about for years to come, and you will remember with a big happy smile.","post_title":"Mark McCabe","post_link":"https:\/\/humanists.scot\/celebrants\/mark-mccabe\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Mark McCabe\" width=\"300\" height=\"196\" src=\"https:\/\/humanists.scot\/wp-content\/uploads\/mark-300x196.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"Celebrants, Central Scotland, Edinburgh &amp; Lothians, Funerals, Glasgow, Location, Mid Scotland &amp; Fife, Type, Weddings","post_tags":"","%_edit_last%":"4","%_edit_lock%":"1666730386:4","%_thumbnail_id%":"1472","%slide_template%":"","%eg_sources_html5_mp4%":"","%eg_sources_html5_ogv%":"","%eg_sources_html5_webm%":"","%eg_sources_youtube%":"","%eg_sources_vimeo%":"","%eg_sources_wistia%":"","%eg_sources_image%":"","%eg_sources_iframe%":"","%eg_sources_soundcloud%":"","%eg_vimeo_ratio%":"1","%eg_youtube_ratio%":"1","%eg_wistia_ratio%":"1","%eg_html5_ratio%":"1","%eg_soundcloud_ratio%":"1","%eg_sources_revslider%":"","%eg_sources_essgrid%":"","%eg_featured_grid%":"","%eg_settings_custom_meta_skin%":"","%eg_settings_custom_meta_element%":"","%eg_settings_custom_meta_setting%":"","%eg_settings_custom_meta_style%":"","%eg_custom_meta_216%":"true","%eg_votes_count%":"0","%_x_entry_body_css_class%":"","%_x_post_layout%":"off","%_x_entry_alternate_index_title%":"","%_x_entry_bg_image_full%":"","%_x_entry_bg_image_full_fade%":"750","%_x_entry_bg_image_full_duration%":"7500","%_x_quote_quote%":"","%_x_quote_cite%":"","%_x_link_url%":"","%_x_video_aspect_ratio%":"16:9","%_x_video_m4v%":"","%_x_video_ogv%":"","%_x_video_embed%":"","%_x_audio_mp3%":"","%_x_audio_ogg%":"","%_x_audio_embed%":"","%_wpgmp_location_address%":"Cumbernauld, Glasgow, UK","%_wpgmp_metabox_latitude%":"55.945668","%_wpgmp_metabox_longitude%":"-3.992534","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_primary_category%":"13","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%ninja_forms_form%":"12","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Celebrants, Central Scotland, Edinburgh &amp; Lothians, Funerals, Glasgow, Location, Mid Scotland &amp; Fife, Type, Weddings","taxonomy=post_tag":"","taxonomy=post_format":""},"icon":"https:\/\/cha.urwinstudio.com\/wp-content\/uploads\/map-marker-1.png"},"id":1471,"infowindow_disable":false},{"source":"post","title":"Anna Drysdale","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\"> \r\n<div class=\"boxPadded\">\r\n<p><a href=\"https:\/\/humanists.scot\/celebrants\/anna-drysdale\/\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Anna Drysdale\" width=\"300\" height=\"196\" src=\"https:\/\/humanists.scot\/wp-content\/uploads\/anna-300x196.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><\/a><\/p>\r\n<h3><a href=\"https:\/\/humanists.scot\/celebrants\/anna-drysdale\/\">Anna Drysdale<\/a><\/h3>\r\n<p>I believe that we can all strive to lead a life where we are mindful of each other, and of our own influence on the lives of others.<\/p>\r\n<a class=\"btn\" href=\"https:\/\/humanists.scot\/celebrants\/anna-drysdale\/\">Celebrant Profile<\/a>\r\n<\/div>\r\n<\/div>","content":"I believe that we can all strive to lead a life where we are mindful of each other, and of our own influence on the lives of others.","address":"Inverurie, UK","location":{"lat":"57.28347400000001","lng":"-2.373995","onclick_action":"marker","redirect_permalink":"https:\/\/humanists.scot\/celebrants\/anna-drysdale\/","zoom":10,"extra_fields":{"post_excerpt":"I believe that we can all strive to lead a life where we are mindful of each other, and of our own influence on the lives of others.","post_content":"I have a varied working background, including hospitality, administration, and elderly care.\u00a0 Whatever the position though, I have always been at the forefront, in customer facing roles, and providing an excellent level of customer care has always been paramount to me.\r\n\r\nI first became interested in Humanist Celebrancy when planning my own wedding in 2014.\u00a0 The more I learned about the philosophy of Humanism the more interested I became. \u00a0It seems clear to me that the key to a better future, whether in terms of an individual level or on a more global perspective, begins with the smallest of steps.\u00a0 I believe that we can all strive to lead a life where we are mindful of each other, and of our own influence on the lives of others.\r\n\r\nAfter much deliberation, I applied to become a Funeral Celebrant, undertaking a process of training, and mentoring, and I was overjoyed to be accepted.\u00a0 For the first time, I felt that this was a job like no other, in that it \u201cfitted\u201d me.\r\n\r\nI never cease to be humbled when invited to conduct a funeral service.\u00a0 It is such a privilege to be able to work with those closest to the deceased. \u00a0A brief visit with the family prior to the funeral means I can gather the information required to create a \u201cbiography\u201d enabling me to conduct the service in a way that it is a meaningful and respectful celebration of the deceased\u2019s life.\u00a0 \u00a0Each service therefore is a specially tailored and unique tribute which also brings some comfort to the bereaved.\r\n<blockquote>\u201cThank you for giving my Nan such a lovely service, we received lots of compliments on how nice the service was under the sad circumstances.\u00a0 You did me, my mum, my uncle, and especially my Nan proud.\u00a0 I\u2019m happy that you were the one who helped us say goodbye to Nan\u201d<\/blockquote>","post_title":"Anna Drysdale","post_link":"https:\/\/humanists.scot\/celebrants\/anna-drysdale\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Anna Drysdale\" width=\"300\" height=\"196\" src=\"https:\/\/humanists.scot\/wp-content\/uploads\/anna-300x196.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"Celebrants, Central Scotland, Edinburgh &amp; Lothians, Funerals, Glasgow, Location, Type","post_tags":"","%_edit_last%":"4","%_edit_lock%":"1666731270:4","%_thumbnail_id%":"1460","%slide_template%":"","%eg_sources_html5_mp4%":"","%eg_sources_html5_ogv%":"","%eg_sources_html5_webm%":"","%eg_sources_youtube%":"","%eg_sources_vimeo%":"","%eg_sources_wistia%":"","%eg_sources_image%":"","%eg_sources_iframe%":"","%eg_sources_soundcloud%":"","%eg_vimeo_ratio%":"1","%eg_youtube_ratio%":"1","%eg_wistia_ratio%":"1","%eg_html5_ratio%":"1","%eg_soundcloud_ratio%":"1","%eg_sources_revslider%":"","%eg_sources_essgrid%":"","%eg_featured_grid%":"","%eg_settings_custom_meta_skin%":"","%eg_settings_custom_meta_element%":"","%eg_settings_custom_meta_setting%":"","%eg_settings_custom_meta_style%":"","%eg_custom_meta_216%":"true","%eg_votes_count%":"0","%_x_entry_body_css_class%":"","%_x_post_layout%":"off","%_x_entry_alternate_index_title%":"","%_x_entry_bg_image_full%":"","%_x_entry_bg_image_full_fade%":"750","%_x_entry_bg_image_full_duration%":"7500","%_x_quote_quote%":"","%_x_quote_cite%":"","%_x_link_url%":"","%_x_video_aspect_ratio%":"16:9","%_x_video_m4v%":"","%_x_video_ogv%":"","%_x_video_embed%":"","%_x_audio_mp3%":"","%_x_audio_ogg%":"","%_x_audio_embed%":"","%_wpgmp_location_address%":"Inverurie, UK","%_wpgmp_metabox_latitude%":"57.28347400000001","%_wpgmp_metabox_longitude%":"-2.373995","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_primary_category%":"13","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%ninja_forms_form%":"14","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Celebrants, Central Scotland, Edinburgh &amp; Lothians, Funerals, Glasgow, Location, Type","taxonomy=post_tag":"","taxonomy=post_format":""},"icon":"https:\/\/cha.urwinstudio.com\/wp-content\/uploads\/map-marker-1.png"},"id":1459,"infowindow_disable":false},{"source":"post","title":"Vicki Langridge","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\"> \r\n<div class=\"boxPadded\">\r\n<p><a href=\"https:\/\/humanists.scot\/celebrants\/vicki-langridge\/\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Vicki Langridge\" width=\"300\" height=\"196\" src=\"https:\/\/humanists.scot\/wp-content\/uploads\/vicki-300x196.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><\/a><\/p>\r\n<h3><a href=\"https:\/\/humanists.scot\/celebrants\/vicki-langridge\/\">Vicki Langridge<\/a><\/h3>\r\n<p>My work has always had people at its heart - I just love getting to know people and hear their life stories.<\/p>\r\n<a class=\"btn\" href=\"https:\/\/humanists.scot\/celebrants\/vicki-langridge\/\">Celebrant Profile<\/a>\r\n<\/div>\r\n<\/div>","content":"My work has always had people at its heart - I just love getting to know people and hear their life stories.","address":"Gartcosh, Glasgow, UK","location":{"lat":"55.88730700000001","lng":"-4.0847009999999955","onclick_action":"marker","redirect_permalink":"https:\/\/humanists.scot\/celebrants\/vicki-langridge\/","zoom":10,"extra_fields":{"post_excerpt":"My work has always had people at its heart - I just love getting to know people and hear their life stories.","post_content":"I\u2019m Vicki and I live in Gartcosh, a small village on the outskirts of Glasgow. I live with my husband and our newest addition, our wee girl who certainly keeps me on my toes!\r\n\r\nAfter graduating from University where I studied Psychology, I worked in various roles within the Care sector. I worked alongside vulnerable adults with wide ranging support needs including Mental Health issues and Learning Disabilities. I currently lead a Young Carers group, enabling Young People time out to learn and explore new activities and friendships.\r\n\r\nFollowing this, I decided to broaden my horizons and embarked on my journey to becoming a Humanist Funeral &amp; Wedding Celebrant which is without a doubt, the most satisfying thing I\u2019ve ever done.\r\n<blockquote>My work has always had people at its heart - I just love getting to know people and hear their life stories.<\/blockquote>\r\nIf I\u2019m not at soft play or a baby class (my life has changed a lot!) I enjoy shopping, having a coffee watching the world go by and walking in the great outdoors with my wee one and husband. It\u2019s the simple things in life.\r\n<h2>Funerals<\/h2>\r\nI have always found Humanist funerals to be personal, loving and a true reflection of a loved ones\u2019 life journey. It gives me a great sense of pride to be guiding others through such a difficult time, knowing their loved one will be given a sincere and fitting send off. I don\u2019t think I could find a greater privilege or responsibility than helping to celebrate someone\u2019s life.\r\n<h2>Weddings<\/h2>\r\nHaving been a guest at a number of Humanist weddings, coupled with my own core values, my husband and I knew we just had to have a Humanist wedding for our own big day back in 2015. We loved every moment of it. We loved how our Celebrant enabled us to put our own stamp on the ceremony. The fun bit was writing \u2018our story\u2019 allowing us to share our happy memories, personal stories, and quirks with our closest friends and family on the day. I feel privileged to now be a part of this exciting process for many happy couples and help put them at ease knowing they\u2019ll be entering marriage with a meaningful and personal ceremony (which they\u2019re very much part of tailoring). The ceremony can be as formal or light-hearted, short and simple or lengthy as you\u2019d like. I\u2019ll guide you through the whole journey which I know will be exciting and fun for each and every couple.","post_title":"Vicki Langridge","post_link":"https:\/\/humanists.scot\/celebrants\/vicki-langridge\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Vicki Langridge\" width=\"300\" height=\"196\" src=\"https:\/\/humanists.scot\/wp-content\/uploads\/vicki-300x196.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"Celebrants, Central Scotland, Edinburgh &amp; Lothians, Funerals, Glasgow, Weddings","post_tags":"","%_edit_last%":"4","%_edit_lock%":"1666731497:4","%_thumbnail_id%":"1456","%slide_template%":"","%eg_sources_html5_mp4%":"","%eg_sources_html5_ogv%":"","%eg_sources_html5_webm%":"","%eg_sources_youtube%":"","%eg_sources_vimeo%":"","%eg_sources_wistia%":"","%eg_sources_image%":"","%eg_sources_iframe%":"","%eg_sources_soundcloud%":"","%eg_vimeo_ratio%":"1","%eg_youtube_ratio%":"1","%eg_wistia_ratio%":"1","%eg_html5_ratio%":"1","%eg_soundcloud_ratio%":"1","%eg_sources_revslider%":"","%eg_sources_essgrid%":"","%eg_featured_grid%":"","%eg_settings_custom_meta_skin%":"","%eg_settings_custom_meta_element%":"","%eg_settings_custom_meta_setting%":"","%eg_settings_custom_meta_style%":"","%eg_custom_meta_216%":"true","%eg_votes_count%":"0","%_x_entry_body_css_class%":"","%_x_post_layout%":"off","%_x_entry_alternate_index_title%":"","%_x_entry_bg_image_full%":"","%_x_entry_bg_image_full_fade%":"750","%_x_entry_bg_image_full_duration%":"7500","%_x_quote_quote%":"","%_x_quote_cite%":"","%_x_link_url%":"","%_x_video_aspect_ratio%":"16:9","%_x_video_m4v%":"","%_x_video_ogv%":"","%_x_video_embed%":"","%_x_audio_mp3%":"","%_x_audio_ogg%":"","%_x_audio_embed%":"","%_wpgmp_location_address%":"Gartcosh, Glasgow, UK","%_wpgmp_metabox_latitude%":"55.88730700000001","%_wpgmp_metabox_longitude%":"-4.0847009999999955","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_primary_category%":"13","%ninja_forms_form%":"15","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Celebrants, Central Scotland, Edinburgh &amp; Lothians, Funerals, Glasgow, Weddings","taxonomy=post_tag":"","taxonomy=post_format":""},"icon":"https:\/\/cha.urwinstudio.com\/wp-content\/uploads\/map-marker-1.png"},"id":1455,"infowindow_disable":false},{"source":"post","title":"Karin Chalmers","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\"> \r\n<div class=\"boxPadded\">\r\n<p><a href=\"https:\/\/humanists.scot\/celebrants\/karin-chalmers\/\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Karin Chalmers\" width=\"300\" height=\"196\" src=\"https:\/\/humanists.scot\/wp-content\/uploads\/blank-300x196.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><\/a><\/p>\r\n<h3><a href=\"https:\/\/humanists.scot\/celebrants\/karin-chalmers\/\">Karin Chalmers<\/a><\/h3>\r\n<p>Working closely with the family I will create a meaningful and dignified ceremony that will help you to say farewell in a personal and memorable way<\/p>\r\n<a class=\"btn\" href=\"https:\/\/humanists.scot\/celebrants\/karin-chalmers\/\">Celebrant Profile<\/a>\r\n<\/div>\r\n<\/div>","content":"Working closely with the family I will create a meaningful and dignified ceremony that will help you to say farewell in a personal and memorable way","address":"Parkhead, Glasgow, UK","location":{"lat":"55.8525698","lng":"-4.197523100000012","onclick_action":"marker","redirect_permalink":"https:\/\/humanists.scot\/celebrants\/karin-chalmers\/","zoom":10,"extra_fields":{"post_excerpt":"Working closely with the family I will create a meaningful and dignified ceremony that will help you to say farewell in a personal and memorable way","post_content":"Hi I\u2019m Karin, I was born in Edinburgh and grew up in the North side of Glasgow.\u00a0 I spent 22 years working for Local Government in Glasgow. In the March of 2003 I embarked on a career as a Registrar with Hertfordshire County Council. This led me to where I am today. From registering births, deaths and marriages I progressed to conducting marriages and funeral services.\r\n\r\nFive years ago I became an independent Celebrant covering Central Scotland. Working closely with the family I will create a meaningful and dignified ceremony that will help you to say farewell in a personal and memorable way. I offer services in funerals, baby namings and renewal of vows.","post_title":"Karin Chalmers","post_link":"https:\/\/humanists.scot\/celebrants\/karin-chalmers\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Karin Chalmers\" width=\"300\" height=\"196\" src=\"https:\/\/humanists.scot\/wp-content\/uploads\/blank-300x196.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"Celebrants, Central Scotland, Edinburgh &amp; Lothians, Funerals, Glasgow, Naming, Weddings","post_tags":"","%_edit_last%":"4","%_edit_lock%":"1666731857:4","%slide_template%":"","%eg_sources_html5_mp4%":"","%eg_sources_html5_ogv%":"","%eg_sources_html5_webm%":"","%eg_sources_youtube%":"","%eg_sources_vimeo%":"","%eg_sources_wistia%":"","%eg_sources_image%":"","%eg_sources_iframe%":"","%eg_sources_soundcloud%":"","%eg_vimeo_ratio%":"1","%eg_youtube_ratio%":"1","%eg_wistia_ratio%":"1","%eg_html5_ratio%":"1","%eg_soundcloud_ratio%":"1","%eg_sources_revslider%":"","%eg_sources_essgrid%":"","%eg_featured_grid%":"","%eg_settings_custom_meta_skin%":"","%eg_settings_custom_meta_element%":"","%eg_settings_custom_meta_setting%":"","%eg_settings_custom_meta_style%":"","%eg_custom_meta_216%":"true","%eg_votes_count%":"0","%_x_entry_body_css_class%":"","%_x_post_layout%":"off","%_x_entry_alternate_index_title%":"","%_x_entry_bg_image_full%":"","%_x_entry_bg_image_full_fade%":"750","%_x_entry_bg_image_full_duration%":"7500","%_x_quote_quote%":"","%_x_quote_cite%":"","%_x_link_url%":"","%_x_video_aspect_ratio%":"16:9","%_x_video_m4v%":"","%_x_video_ogv%":"","%_x_video_embed%":"","%_x_audio_mp3%":"","%_x_audio_ogg%":"","%_x_audio_embed%":"","%_wpgmp_location_address%":"Parkhead, Glasgow, UK","%_wpgmp_metabox_latitude%":"55.8525698","%_wpgmp_metabox_longitude%":"-4.197523100000012","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_content_score%":"90","%_yoast_wpseo_primary_category%":"13","%_thumbnail_id%":"1454","%ninja_forms_form%":"16","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Celebrants, Central Scotland, Edinburgh &amp; Lothians, Funerals, Glasgow, Naming, Weddings","taxonomy=post_tag":"","taxonomy=post_format":""},"icon":"https:\/\/cha.urwinstudio.com\/wp-content\/uploads\/map-marker-1.png"},"id":1452,"infowindow_disable":false},{"source":"post","title":"Stephen McKerr","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\"> \r\n<div class=\"boxPadded\">\r\n<p><a href=\"https:\/\/humanists.scot\/celebrants\/stephen-mckerr\/\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Stephen McKerr\" width=\"300\" height=\"196\" src=\"https:\/\/humanists.scot\/wp-content\/uploads\/stephen-1-300x196.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><\/a><\/p>\r\n<h3><a href=\"https:\/\/humanists.scot\/celebrants\/stephen-mckerr\/\">Stephen McKerr<\/a><\/h3>\r\n<p>A Humanist Celebration affords choice and inclusion and this offers a bespoke and personal nature of ceremony as unique as the couple themselves.<\/p>\r\n<a class=\"btn\" href=\"https:\/\/humanists.scot\/celebrants\/stephen-mckerr\/\">Celebrant Profile<\/a>\r\n<\/div>\r\n<\/div>","content":"A Humanist Celebration affords choice and inclusion and this offers a bespoke and personal nature of ceremony as unique as the couple themselves.","address":"Wishaw, UK","location":{"lat":"55.773543","lng":"-3.9193539999999985","onclick_action":"marker","redirect_permalink":"https:\/\/humanists.scot\/celebrants\/stephen-mckerr\/","zoom":10,"extra_fields":{"post_excerpt":"A Humanist Celebration affords choice and inclusion and this offers a bespoke and personal nature of ceremony as unique as the couple themselves.","post_content":"My name is Stephen McKerr. I live in Wishaw and have done so all of my life \u2013 I keep telling myself to broaden my horizons, but can\u2019t seem to leave the wee town behind me! Home is where the heart is after all.\r\n\r\nI have enjoyed quite a varied career so far. I went to Motherwell College and achieved an HND in Business Administration. This prepared me well for a variety of jobs in business from Civil Service, independent local companies, national organisations and even a short stint in a call centre.\r\n\r\nLater in life, in fact on my 30th birthday, I had my very first day at University of Strathclyde where I studied English for 4 years, leaving with an honours degree.\r\n\r\nDuring this time of study, I found my niche in life when I entered into the hospitality sector. I could put all my best skills into practice as well as having the privilege of being personally involved in couples\u2019 weddings, which I have been doing for the last 8 years. The last 3 years have been spent as a dedicated wedding co-ordinator as part of an award winning team. It just seems natural to progress to now conducting the ceremony itself.\r\n<blockquote>A Humanist Celebration affords choice and inclusion and this offers a bespoke and personal nature of ceremony as unique as the couple themselves.<\/blockquote>\r\nAway from work, I like to relax by watching TV or movies (the old ones are most certainly the best) and reading, still enjoying the classics \u2013 Oliver Twist is one of my all time favourites\r\n\r\nI make sure I find time for my family and friends spending days out at the cinema, or out looking around the shops \u2013 I can\u2019t pass a candle shop though! Of course, there is the occasional night out.\r\n\r\nHaving witnessed hundreds of wedding ceremonies in my working life and of many different styles, I have always preferred Humanism for its dignified, yet informal tone. A Humanist Celebration affords choice and inclusion and this offers a bespoke and personal nature of ceremony as unique as the couple themselves.","post_title":"Stephen McKerr","post_link":"https:\/\/humanists.scot\/celebrants\/stephen-mckerr\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Stephen McKerr\" width=\"300\" height=\"196\" src=\"https:\/\/humanists.scot\/wp-content\/uploads\/stephen-1-300x196.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"Celebrants, Central Scotland, Edinburgh &amp; Lothians, Glasgow, Weddings","post_tags":"","%_edit_last%":"4","%_edit_lock%":"1666732022:4","%_thumbnail_id%":"1448","%slide_template%":"","%eg_sources_html5_mp4%":"","%eg_sources_html5_ogv%":"","%eg_sources_html5_webm%":"","%eg_sources_youtube%":"","%eg_sources_vimeo%":"","%eg_sources_wistia%":"","%eg_sources_image%":"","%eg_sources_iframe%":"","%eg_sources_soundcloud%":"","%eg_vimeo_ratio%":"1","%eg_youtube_ratio%":"1","%eg_wistia_ratio%":"1","%eg_html5_ratio%":"1","%eg_soundcloud_ratio%":"1","%eg_sources_revslider%":"","%eg_sources_essgrid%":"","%eg_featured_grid%":"","%eg_settings_custom_meta_skin%":"","%eg_settings_custom_meta_element%":"","%eg_settings_custom_meta_setting%":"","%eg_settings_custom_meta_style%":"","%eg_custom_meta_216%":"true","%eg_votes_count%":"0","%eg-subtitle%":"","%eg-sleeps%":"","%_x_entry_body_css_class%":"","%_x_post_layout%":"off","%_x_entry_alternate_index_title%":"","%_x_entry_bg_image_full%":"","%_x_entry_bg_image_full_fade%":"750","%_x_entry_bg_image_full_duration%":"7500","%_x_quote_quote%":"","%_x_quote_cite%":"","%_x_link_url%":"","%_x_video_aspect_ratio%":"16:9","%_x_video_m4v%":"","%_x_video_ogv%":"","%_x_video_embed%":"","%_x_audio_mp3%":"","%_x_audio_ogg%":"","%_x_audio_embed%":"","%_wpgmp_location_address%":"Wishaw, UK","%_wpgmp_metabox_latitude%":"55.773543","%_wpgmp_metabox_longitude%":"-3.9193539999999985","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_content_score%":"30","%_yoast_wpseo_primary_category%":"13","%ninja_forms_form%":"17","%_yoast_wpseo_estimated-reading-time-minutes%":"2","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Celebrants, Central Scotland, Edinburgh &amp; Lothians, Glasgow, Weddings","taxonomy=post_tag":"","taxonomy=post_format":""},"icon":"https:\/\/cha.urwinstudio.com\/wp-content\/uploads\/map-marker-1.png"},"id":1392,"infowindow_disable":false},{"source":"post","title":"Julie Reid","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\"> \r\n<div class=\"boxPadded\">\r\n<p><a href=\"https:\/\/humanists.scot\/celebrants\/julie-reid\/\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Julie Reid\" width=\"300\" height=\"196\" src=\"https:\/\/humanists.scot\/wp-content\/uploads\/julie-1-300x196.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><\/a><\/p>\r\n<h3><a href=\"https:\/\/humanists.scot\/celebrants\/julie-reid\/\">Julie Reid<\/a><\/h3>\r\n<p>What will be apparent no matter what, is your love for each other; the affection and friendship that you share and the deep and the binding commitment that you are making to each other<\/p>\r\n<a class=\"btn\" href=\"https:\/\/humanists.scot\/celebrants\/julie-reid\/\">Celebrant Profile<\/a>\r\n<\/div>\r\n<\/div>","content":"What will be apparent no matter what, is your love for each other; the affection and friendship that you share and the deep and the binding commitment that you are making to each other","address":"Carluke, UK","location":{"lat":"55.735435","lng":"-3.836552","onclick_action":"marker","redirect_permalink":"https:\/\/humanists.scot\/celebrants\/julie-reid\/","zoom":10,"extra_fields":{"post_excerpt":"What will be apparent no matter what, is your love for each other; the affection and friendship that you share and the deep and the binding commitment that you are making to each other","post_content":"I'm Julie and I live in rural Lanarkshire, near Carluke. Having been born and brought up on a council estate in the Burnbank area of Hamilton and attended Uni in Glasgow, I know the West of Scotland well.\u00a0 However, I have worked in and around West Lothian and Edinburgh and am enjoying continuing to expand my knowledge of this area too!\r\n\r\nMy life experiences so far have been pretty varied \u2013 my background is in education, teaching English and creative writing, but I successfully set up and ran my own equestrian business before deciding to commit to Celebrancy on a full time basis.\r\n\r\nI joined the Humanist Society Scotland a number of years ago after the funeral of my Grandfather \u2013 a lifelong atheist for whom a humanist ceremony was not only entirely fitting but much more meaningful than any ceremony I had previously attended. A few years later I successfully applied to become a celebrant myself and since then have conducted hundreds of ceremonies \u2013 every one unique and personal. Outwith Celebrancy I am kept busy looking after my family \u2013 including the four legged kind- but I enjoy travel, reading and the occasional night out.\r\n<blockquote>I joined the Humanist Society Scotland a number of years ago after the funeral of my Grandfather \u2013 a lifelong atheist for whom a humanist ceremony was not only entirely fitting but much more meaningful than any ceremony I had previously attended.<\/blockquote>\r\nThe nature of the ceremony is dependent entirely on what you feel comfortable including. It can be short and simple, or it can be more expansive. It can be formal or informal, or a mixture of both; for example the light-hearted telling of the story of how you both came to be standing there on the day, contrasting with the solemnity of the vows.\r\n\r\nWhat will be apparent no matter what, is your love for each other; the affection and friendship that you share and the deep and the binding commitment that you are making to each other, in the company of those you love the most; your family and close friends.\r\n\r\n<img class=\"alignnone size-full wp-image-1445\" src=\"https:\/\/humanists.scot\/wp-content\/uploads\/julie2.jpg\" alt=\"\" width=\"1200\" height=\"783\" \/>\r\n\r\nIf you are considering asking me to conduct your ceremony, you may find it useful to have an appreciation of how I would work with you from first contact right up until the big day itself.\r\n\r\nThe first stage is contacting me to confirm availability, having a chat on the telephone then, if you are happy to proceed, confirming your booking.\r\n\r\nOnce we have done that, I would send you some ideas for the content of the ceremony, in order that you can begin the process of personalising the ceremony to your requirements.\r\n\r\nWhen you have had the opportunity to decide on the content (some brides to be even include their partner in this stage!), even if it is only rough ideas, we can then meet up and discuss how the ceremony will unfold. This would normally be 2 to 3 months before the date (this timescale can be adapted to suit the circumstances).\r\n\r\nApproximately 2 to 3 weeks before the big day, I would send you a draft ceremony and you can advise of any changes. Once we have the final draft, all you then need to do is:\r\n<ol>\r\n \t<li>Turn up on the day.<\/li>\r\n \t<li>Enjoy the occasion.<\/li>\r\n \t<li>Live happily ever after.<\/li>\r\n<\/ol>\r\n&nbsp;","post_title":"Julie Reid","post_link":"https:\/\/humanists.scot\/celebrants\/julie-reid\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Julie Reid\" width=\"300\" height=\"196\" src=\"https:\/\/humanists.scot\/wp-content\/uploads\/julie-1-300x196.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"Celebrants, Central Scotland, Edinburgh &amp; Lothians, Funerals, Glasgow, Mid Scotland &amp; Fife, Naming, South Scotland, Weddings, West Scotland","post_tags":"","%_edit_last%":"4","%_edit_lock%":"1683063187:4","%_thumbnail_id%":"1444","%slide_template%":"","%eg_sources_html5_mp4%":"","%eg_sources_html5_ogv%":"","%eg_sources_html5_webm%":"","%eg_sources_youtube%":"","%eg_sources_vimeo%":"","%eg_sources_wistia%":"","%eg_sources_image%":"","%eg_sources_iframe%":"","%eg_sources_soundcloud%":"","%eg_vimeo_ratio%":"1","%eg_youtube_ratio%":"1","%eg_wistia_ratio%":"1","%eg_html5_ratio%":"1","%eg_soundcloud_ratio%":"1","%eg_sources_revslider%":"","%eg_sources_essgrid%":"","%eg_featured_grid%":"","%eg_settings_custom_meta_skin%":"","%eg_settings_custom_meta_element%":"","%eg_settings_custom_meta_setting%":"","%eg_settings_custom_meta_style%":"","%eg_custom_meta_216%":"true","%eg_votes_count%":"0","%eg-subtitle%":"","%eg-sleeps%":"","%_x_entry_body_css_class%":"","%_x_post_layout%":"off","%_x_entry_alternate_index_title%":"","%_x_entry_bg_image_full%":"","%_x_entry_bg_image_full_fade%":"750","%_x_entry_bg_image_full_duration%":"7500","%_x_quote_quote%":"","%_x_quote_cite%":"","%_x_link_url%":"","%_x_video_aspect_ratio%":"16:9","%_x_video_m4v%":"","%_x_video_ogv%":"","%_x_video_embed%":"","%_x_audio_mp3%":"","%_x_audio_ogg%":"","%_x_audio_embed%":"","%_wpgmp_location_address%":"Carluke, UK","%_wpgmp_metabox_latitude%":"55.735435","%_wpgmp_metabox_longitude%":"-3.836552","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_primary_category%":"13","%_yoast_wpseo_estimated-reading-time-minutes%":"3","%_wp_old_slug%":"julie-reed","%ninja_forms_form%":"5","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Celebrants, Central Scotland, Edinburgh &amp; Lothians, Funerals, Glasgow, Mid Scotland &amp; Fife, Naming, South Scotland, Weddings, West Scotland","taxonomy=post_tag":"","taxonomy=post_format":""},"icon":"https:\/\/cha.urwinstudio.com\/wp-content\/uploads\/map-marker-1.png"},"id":1393,"infowindow_disable":false},{"source":"post","title":"Andy McSorley","infowindow_content":"<div class=\"fc-item-box fc-item-no-padding\"> \r\n<div class=\"boxPadded\">\r\n<p><a href=\"https:\/\/humanists.scot\/celebrants\/andy-mcsorley\/\"><div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Andy McSorley\" width=\"300\" height=\"196\" src=\"https:\/\/humanists.scot\/wp-content\/uploads\/andy2-300x196.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div><\/a><\/p>\r\n<h3><a href=\"https:\/\/humanists.scot\/celebrants\/andy-mcsorley\/\">Andy McSorley<\/a><\/h3>\r\n<p>Families have told me that it brought them great comfort to celebrate their loved one's life in such a way and I have received some very moving and heartfelt expressions of thanks<\/p>\r\n<a class=\"btn\" href=\"https:\/\/humanists.scot\/celebrants\/andy-mcsorley\/\">Celebrant Profile<\/a>\r\n<\/div>\r\n<\/div>","content":"Families have told me that it brought them great comfort to celebrate their loved one's life in such a way and I have received some very moving and heartfelt expressions of thanks","address":"Carluke, UK","location":{"lat":"55.735435","lng":"-3.836552000000001","onclick_action":"marker","redirect_permalink":"https:\/\/humanists.scot\/celebrants\/andy-mcsorley\/","zoom":10,"extra_fields":{"post_excerpt":"Families have told me that it brought them great comfort to celebrate their loved one's life in such a way and I have received some very moving and heartfelt expressions of thanks","post_content":"I'm Andy and I've been a celebrant since January 2011. I was born and brought up in the east-end of Glasgow. My educational background was firstly in Electronics then later Law. I have served in the Army where I completed two tours of duty in Bosnia in the 90s, been a civil servant, worked in investment banking in the City of London and spent some time as a commercial diver mainly in the murky, freezing depths of lochs in the North of Scotland. I am now a full-time celebrant and my experiences enable me to relate to and connect with people from all backgrounds. My personal interests include reading, messing about with computers, spending time with family and friends and watching the football on the television.\r\n<h2>Weddings<\/h2>\r\nA Humanist Ceremony gives you the freedom to really put your stamp on one of the most important days in your life. The nature of the ceremony is dependent entirely on what you feel comfortable including. It can be short and simple, or it can be more expansive. It can be formal or informal, or a mixture of both; for example the light-hearted telling of the story of how you both came to be standing there on the day, contrasting with the solemnity of the vows.\r\n\r\nWhat will be apparent no matter what, is your love for each other; the affection and friendship that you share and the deep and the binding commitment that you are making to each other, in the company of those you love the most; your family and close friends.\r\n\r\nIf you are considering asking me to conduct your ceremony, you may find it useful to have an appreciation of how I would work with you from first contact right up until the big day itself.\r\n\r\nThe first stage is contacting me to confirm availability, having a chat on the telephone then, if you are happy to proceed, confirming your booking.\r\n\r\nOnce we have done that, I would send you some ideas for the content of the ceremony, in order that you can begin the process of personalising the ceremony to your requirements.\r\n\r\nWhen you have had the opportunity to decide on the content (some brides to be even include their partner in this stage!), even if it is only rough ideas, we can then meet up and discuss how the ceremony will unfold. This would normally be 2 to 3 months before the date (this timescale can be adapted to suit the circumstances).\r\n\r\nApproximately 2 to 3 weeks before the big day, I would send you a draft ceremony and you can advise of any changes. Once we have the final draft, all you then need to do is:\r\n<ol>\r\n \t<li>Turn up on the day.<\/li>\r\n \t<li>Enjoy the occasion.<\/li>\r\n \t<li>Live happily ever after!<\/li>\r\n<\/ol>\r\n<h2>Funerals<\/h2>\r\n<span data-contrast=\"auto\">For families, it's an important part of the grieving process that their loved one has the type of funeral which is in keeping with the way in which they lived their life.<\/span>\r\n\r\n<span data-contrast=\"auto\">Everyone has a story to tell and my job is to get as much of that story as possible from family and friends. Some stories are quiet and gentle. Some are more- shall we say- eventful. All are equally valid and deserve to be told with respect, warmth and often a touch of humour. Each person's ceremony is unique because they themselves were unique.<\/span>\r\n\r\n<span data-contrast=\"auto\">Families often tell me when I visit that that their loved one was \"a quiet wee man\/woman so there won't be much to say\". Often, with a bit of gentle prompting from myself and more than an hour later I am sti<\/span><span data-contrast=\"auto\">ll furiously writing notes.\u00a0<\/span><span data-ccp-props=\"{&quot;201341983&quot;:0,&quot;335559739&quot;:160,&quot;335559740&quot;:259}\">\u00a0<\/span>\r\n\r\n<span data-contrast=\"auto\">The reason for this is it's the little things that are important. It's the little things that you remember about someone that makes them special. The nights at the bingo; the days at the beach; the pint in a local while putting the world to rights; their favourite sayings; these will be the abiding memories you have of someone who played such an\u00a0<\/span><span data-contrast=\"auto\">important part in your life.<\/span><span data-ccp-props=\"{&quot;201341983&quot;:0,&quot;335559739&quot;:160,&quot;335559740&quot;:259}\">\u00a0<\/span>\r\n\r\n<span data-contrast=\"auto\">Families have told me that it brought them great comfort to celebrate their loved one's life in such a way and I have received some very moving and hear<\/span><span data-contrast=\"auto\">tfelt expressions of thanks:<\/span><span data-ccp-props=\"{&quot;201341983&quot;:0,&quot;335559739&quot;:160,&quot;335559740&quot;:259}\">\u00a0<\/span>\r\n\r\n<em><span data-contrast=\"auto\">\"I have childhood memories of my mum enjoying those seaside bingo games. You know those ones at seaside fairs where you flipped the numbers over. Again M<\/span><span data-contrast=\"auto\">um wanted to be a winner. Anyway a little thing.\u00a0<\/span><\/em><span data-contrast=\"auto\"><em>Look forward to hearing the eulogy on Thursday. Chatting with you has already got us into a better frame of mind to celebrate her life\"<\/em>. R.M. Ed<\/span><span data-contrast=\"auto\">inburgh<\/span><span data-ccp-props=\"{&quot;201341983&quot;:0,&quot;335559739&quot;:160,&quot;335559740&quot;:259}\">\u00a0<\/span>\r\n\r\n<em><span data-contrast=\"auto\">\"Thanks again for making a very difficult day less so, and I wish you all the very best for the future. You have a gift, and you are able to put it to very good use - there's not many of us tha<\/span><\/em><span data-contrast=\"auto\"><em>t can claim that.\"<\/em>\u00a0A.M. Glasgow<\/span><span data-ccp-props=\"{&quot;201341983&quot;:0,&quot;335559739&quot;:160,&quot;335559740&quot;:259}\">\u00a0<\/span>\r\n\r\n<em><span data-contrast=\"auto\">\"I knew I would cry but I honestly didn't think I could smile that day, but through your words\u00a0<\/span><span data-contrast=\"auto\">myself<\/span><span data-contrast=\"auto\">\u00a0and others actually laughed out loud during the stor<\/span><span data-contrast=\"auto\">ies you told \u2013 amazing\u2026<\/span><span data-ccp-props=\"{&quot;201341983&quot;:0,&quot;335559739&quot;:160,&quot;335559740&quot;:259}\">\u00a0<\/span><\/em>\r\n\r\n<em><span data-contrast=\"auto\">\u2026\u00a0<\/span><span data-contrast=\"auto\">our<\/span><span data-contrast=\"auto\">\u00a0hearts are broken and I wonder if they will ever mend but you helped us give B the most moving tribute possible and we will always appreciate th<\/span><\/em><span data-contrast=\"auto\"><em>at.\"<\/em>\u00a0J.M. East Kilbride<\/span><span data-ccp-props=\"{&quot;201341983&quot;:0,&quot;335559739&quot;:160,&quot;335559740&quot;:259}\">\u00a0<\/span>\r\n\r\n<span data-contrast=\"auto\">\"<em>\u2026\u00a0<\/em><\/span><em><span data-contrast=\"auto\">we<\/span><span data-contrast=\"auto\">\u00a0are all truly grateful for the service that you provide for leading up to the day of the funeral and especially on the day of the funeral. We were able to remember G with a wry smile upon our\u00a0<\/span><span data-contrast=\"auto\">faces as\u00a0<\/span><span data-contrast=\"auto\">well as a tear in our eye.\u00a0<\/span><\/em><span data-contrast=\"auto\"><em>Your attention to detail was exceptional and was greatly appreciated.\"<\/em>\u00a0G.B.\u00a0<\/span><span data-contrast=\"auto\">Moodiesburn<\/span><span data-ccp-props=\"{&quot;201341983&quot;:0,&quot;335559739&quot;:160,&quot;335559740&quot;:259}\">\u00a0<\/span>","post_title":"Andy McSorley","post_link":"https:\/\/humanists.scot\/celebrants\/andy-mcsorley\/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Andy McSorley\" width=\"300\" height=\"196\" src=\"https:\/\/humanists.scot\/wp-content\/uploads\/andy2-300x196.jpg\" class=\"wp-post-image   wpgmp_featured_image\" ><\/div>","post_categories":"Celebrants, Central Scotland, Edinburgh &amp; Lothians, Funerals, Glasgow, Highlands &amp; Islands, Location, Mid Scotland &amp; Fife, Naming, North East Scotland, South Scotland, Type, Weddings, West Scotland","post_tags":"","%_edit_last%":"4","%_edit_lock%":"1685399784:4","%_thumbnail_id%":"1441","%slide_template%":"","%eg_sources_html5_mp4%":"","%eg_sources_html5_ogv%":"","%eg_sources_html5_webm%":"","%eg_sources_youtube%":"","%eg_sources_vimeo%":"","%eg_sources_wistia%":"","%eg_sources_image%":"","%eg_sources_iframe%":"","%eg_sources_soundcloud%":"","%eg_vimeo_ratio%":"1","%eg_youtube_ratio%":"1","%eg_wistia_ratio%":"1","%eg_html5_ratio%":"1","%eg_soundcloud_ratio%":"1","%eg_sources_revslider%":"","%eg_sources_essgrid%":"","%eg_featured_grid%":"","%eg_settings_custom_meta_skin%":"","%eg_settings_custom_meta_element%":"","%eg_settings_custom_meta_setting%":"","%eg_settings_custom_meta_style%":"","%eg_custom_meta_216%":"true","%eg_votes_count%":"0","%eg-subtitle%":"","%eg-sleeps%":"","%_x_entry_body_css_class%":"","%_x_post_layout%":"off","%_x_entry_alternate_index_title%":"","%_x_entry_bg_image_full%":"","%_x_entry_bg_image_full_fade%":"750","%_x_entry_bg_image_full_duration%":"7500","%_x_quote_quote%":"","%_x_quote_cite%":"","%_x_link_url%":"","%_x_video_aspect_ratio%":"16:9","%_x_video_m4v%":"","%_x_video_ogv%":"","%_x_video_embed%":"","%_x_audio_mp3%":"","%_x_audio_ogg%":"","%_x_audio_embed%":"","%_wpgmp_location_address%":"Carluke, UK","%_wpgmp_metabox_latitude%":"55.735435","%_wpgmp_metabox_longitude%":"-3.836552000000001","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"3\";}","%_wpgmp_metabox_marker_id%":"N;","%_wpgmp_metabox_taxomomies_terms%":"N;","%_wpgmp_extensions_fields%":"N;","%_yoast_wpseo_content_score%":"60","%_yoast_wpseo_primary_category%":"13","%ninja_forms_form%":"4","%_yoast_wpseo_estimated-reading-time-minutes%":"5","%_yoast_wpseo_wordproof_timestamp%":"","taxonomy=category":"Celebrants, Central Scotland, Edinburgh &amp; Lothians, Funerals, Glasgow, Highlands &amp; Islands, Location, Mid Scotland &amp; Fife, Naming, North East Scotland, South Scotland, Type, Weddings, West Scotland","taxonomy=post_tag":"","taxonomy=post_format":""},"icon":"https:\/\/cha.urwinstudio.com\/wp-content\/uploads\/map-marker-1.png"},"id":1378,"infowindow_disable":false}],"map_property":{"map_id":"3","debug_mode":false},"shapes":{"drawing_editable":false},"filters":{"filters_container":"[data-container=\"wpgmp-filters-container\"]"}}